Added missing tegra files.HEADmaster

76 files changed, 35983 insertions, 0 deletions

diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig
new file mode 100644
index 00000000000..5d73dec8ac0
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/Kconfig
@@ -0,0 +1,376 @@
+config DVB_USB
+        tristate "Support for various USB DVB devices"
+        depends on DVB_CORE && USB && I2C && RC_CORE
+        help
+          By enabling this you will be able to choose the various supported
+          USB1.1 and USB2.0 DVB devices.
+
+          Almost every USB device needs a firmware, please look into
+          <file:Documentation/dvb/README.dvb-usb>.
+
+          For a complete list of supported USB devices see the LinuxTV DVB Wiki:
+          <http://www.linuxtv.org/wiki/index.php/DVB_USB>
+
+          Say Y if you own a USB DVB device.
+
+config DVB_USB_DEBUG
+        bool "Enable extended debug support for all DVB-USB devices"
+        depends on DVB_USB
+        help
+          Say Y if you want to enable debugging. See modinfo dvb-usb (and the
+          appropriate drivers) for debug levels.
+
+config DVB_USB_A800
+        tristate "AVerMedia AverTV DVB-T USB 2.0 (A800)"
+        depends on DVB_USB
+        select DVB_DIB3000MC
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_MT2060 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the AVerMedia AverTV DVB-T USB 2.0 (A800) receiver.
+
+config DVB_USB_DIBUSB_MB
+        tristate "DiBcom USB DVB-T devices (based on the DiB3000M-B) (see help for device list)"
+        depends on DVB_USB
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        select DVB_DIB3000MB
+        select MEDIA_TUNER_MT2060 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Support for USB 1.1 and 2.0 DVB-T receivers based on reference designs made by
+          DiBcom (<http://www.dibcom.fr>) equipped with a DiB3000M-B demodulator.
+
+          For an up-to-date list of devices supported by this driver, have a look
+          on the Linux-DVB Wiki at www.linuxtv.org.
+
+          Say Y if you own such a device and want to use it. You should build it as
+          a module.
+
+config DVB_USB_DIBUSB_MB_FAULTY
+        bool "Support faulty USB IDs"
+        depends on DVB_USB_DIBUSB_MB
+        help
+          Support for faulty USB IDs due to an invalid EEPROM on some Artec devices.
+
+config DVB_USB_DIBUSB_MC
+        tristate "DiBcom USB DVB-T devices (based on the DiB3000M-C/P) (see help for device list)"
+        depends on DVB_USB
+        select DVB_DIB3000MC
+        select MEDIA_TUNER_MT2060 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Support for USB2.0 DVB-T receivers based on reference designs made by
+          DiBcom (<http://www.dibcom.fr>) equipped with a DiB3000M-C/P demodulator.
+
+          For an up-to-date list of devices supported by this driver, have a look
+          on the Linux-DVB Wiki at www.linuxtv.org.
+
+          Say Y if you own such a device and want to use it. You should build it as
+          a module.
+
+config DVB_USB_DIB0700
+        tristate "DiBcom DiB0700 USB DVB devices (see help for supported devices)"
+        depends on DVB_USB
+        select DVB_DIB7000P if !DVB_FE_CUSTOMISE
+        select DVB_DIB7000M if !DVB_FE_CUSTOMISE
+        select DVB_DIB8000 if !DVB_FE_CUSTOMISE
+        select DVB_DIB3000MC if !DVB_FE_CUSTOMISE
+        select DVB_S5H1411 if !DVB_FE_CUSTOMISE
+        select DVB_LGDT3305 if !DVB_FE_CUSTOMISE
+        select DVB_TUNER_DIB0070 if !DVB_FE_CUSTOMISE
+        select DVB_TUNER_DIB0090 if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_MT2060 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_MT2266 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_XC2028 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_XC5000 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_XC4000 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_MXL5007T if !MEDIA_TUNER_CUSTOMISE
+        help
+          Support for USB2.0/1.1 DVB receivers based on the DiB0700 USB bridge. The
+          USB bridge is also present in devices having the DiB7700 DVB-T-USB
+          silicon. This chip can be found in devices offered by Hauppauge,
+          Avermedia and other big and small companies.
+
+          For an up-to-date list of devices supported by this driver, have a look
+          on the LinuxTV Wiki at www.linuxtv.org.
+
+          Say Y if you own such a device and want to use it. You should build it as
+          a module.
+
+config DVB_USB_UMT_010
+        tristate "HanfTek UMT-010 DVB-T USB2.0 support"
+        depends on DVB_USB
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        select DVB_DIB3000MC
+        select MEDIA_TUNER_MT2060 if !MEDIA_TUNER_CUSTOMISE
+        select DVB_MT352 if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the HanfTek UMT-010 USB2.0 stick-sized DVB-T receiver.
+
+config DVB_USB_CXUSB
+        tristate "Conexant USB2.0 hybrid reference design support"
+        depends on DVB_USB
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        select DVB_CX22702 if !DVB_FE_CUSTOMISE
+        select DVB_LGDT330X if !DVB_FE_CUSTOMISE
+        select DVB_MT352 if !DVB_FE_CUSTOMISE
+        select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+        select DVB_DIB7000P if !DVB_FE_CUSTOMISE
+        select DVB_TUNER_DIB0070 if !DVB_FE_CUSTOMISE
+        select DVB_ATBM8830 if !DVB_FE_CUSTOMISE
+        select DVB_LGS8GXX if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_SIMPLE if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_XC2028 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_MXL5005S if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_MAX2165 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the Conexant USB2.0 hybrid reference design.
+          Currently, only DVB and ATSC modes are supported, analog mode
+          shall be added in the future. Devices that require this module:
+
+          Medion MD95700 hybrid USB2.0 device.
+          DViCO FusionHDTV (Bluebird) USB2.0 devices
+
+config DVB_USB_M920X
+        tristate "Uli m920x DVB-T USB2.0 support"
+        depends on DVB_USB
+        select DVB_MT352 if !DVB_FE_CUSTOMISE
+        select DVB_TDA1004X if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_QT1010 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_TDA827X if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_SIMPLE if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the MSI Mega Sky 580 USB2.0 DVB-T receiver.
+          Currently, only devices with a product id of
+          "DTV USB MINI" (in cold state) are supported.
+          Firmware required.
+
+config DVB_USB_GL861
+        tristate "Genesys Logic GL861 USB2.0 support"
+        depends on DVB_USB
+        select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_QT1010 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the MSI Megasky 580 (55801) DVB-T USB2.0
+          receiver with USB ID 0db0:5581.
+
+config DVB_USB_AU6610
+        tristate "Alcor Micro AU6610 USB2.0 support"
+        depends on DVB_USB
+        select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_QT1010 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the Sigmatek DVB-110 DVB-T USB2.0 receiver.
+
+config DVB_USB_DIGITV
+        tristate "Nebula Electronics uDigiTV DVB-T USB2.0 support"
+        depends on DVB_USB
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        select DVB_NXT6000 if !DVB_FE_CUSTOMISE
+        select DVB_MT352 if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the Nebula Electronics uDigitV USB2.0 DVB-T receiver.
+
+config DVB_USB_VP7045
+        tristate "TwinhanDTV Alpha/MagicBoxII, DNTV tinyUSB2, Beetle USB2.0 support"
+        depends on DVB_USB
+        help
+          Say Y here to support the
+
+            TwinhanDTV Alpha (stick) (VP-7045),
+                TwinhanDTV MagicBox II (VP-7046),
+                DigitalNow TinyUSB 2 DVB-t,
+                DigitalRise USB 2.0 Ter (Beetle) and
+                TYPHOON DVB-T USB DRIVE
+
+          DVB-T USB2.0 receivers.
+
+config DVB_USB_VP702X
+        tristate "TwinhanDTV StarBox and clones DVB-S USB2.0 support"
+        depends on DVB_USB
+        help
+          Say Y here to support the
+
+            TwinhanDTV StarBox,
+                DigitalRise USB Starbox and
+                TYPHOON DVB-S USB 2.0 BOX
+
+          DVB-S USB2.0 receivers.
+
+config DVB_USB_GP8PSK
+        tristate "GENPIX 8PSK->USB module support"
+        depends on DVB_USB
+        help
+          Say Y here to support the
+            GENPIX 8psk module
+
+          DVB-S USB2.0 receivers.
+
+config DVB_USB_NOVA_T_USB2
+        tristate "Hauppauge WinTV-NOVA-T usb2 DVB-T USB2.0 support"
+        depends on DVB_USB
+        select DVB_DIB3000MC
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_MT2060 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the Hauppauge WinTV-NOVA-T usb2 DVB-T USB2.0 receiver.
+
+config DVB_USB_TTUSB2
+        tristate "Pinnacle 400e DVB-S USB2.0 support"
+        depends on DVB_USB
+        select DVB_TDA10086 if !DVB_FE_CUSTOMISE
+        select DVB_LNBP21 if !DVB_FE_CUSTOMISE
+        select DVB_TDA826X if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the Pinnacle 400e DVB-S USB2.0 receiver. The
+          firmware protocol used by this module is similar to the one used by the
+          old ttusb-driver - that's why the module is called dvb-usb-ttusb2.
+
+config DVB_USB_DTT200U
+        tristate "WideView WT-200U and WT-220U (pen) DVB-T USB2.0 support (Yakumo/Hama/Typhoon/Yuan)"
+        depends on DVB_USB
+        help
+          Say Y here to support the WideView/Yakumo/Hama/Typhoon/Yuan DVB-T USB2.0 receiver.
+
+          The receivers are also known as DTT200U (Yakumo) and UB300 (Yuan).
+
+          The WT-220U and its clones are pen-sized.
+
+config DVB_USB_OPERA1
+        tristate "Opera1 DVB-S USB2.0 receiver"
+        depends on DVB_USB
+        select DVB_STV0299 if !DVB_FE_CUSTOMISE
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the Opera DVB-S USB2.0 receiver.
+
+config DVB_USB_AF9005
+        tristate "Afatech AF9005 DVB-T USB1.1 support"
+        depends on DVB_USB && EXPERIMENTAL
+        select MEDIA_TUNER_MT2060 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_QT1010 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the Afatech AF9005 based DVB-T USB1.1 receiver
+          and the TerraTec Cinergy T USB XE (Rev.1)
+
+config DVB_USB_AF9005_REMOTE
+        tristate "Afatech AF9005 default remote control support"
+        depends on DVB_USB_AF9005
+        help
+          Say Y here to support the default remote control decoding for the
+          Afatech AF9005 based receiver.
+
+config DVB_USB_DW2102
+        tristate "DvbWorld & TeVii DVB-S/S2 USB2.0 support"
+        depends on DVB_USB
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        select DVB_STV0299 if !DVB_FE_CUSTOMISE
+        select DVB_STV0288 if !DVB_FE_CUSTOMISE
+        select DVB_STB6000 if !DVB_FE_CUSTOMISE
+        select DVB_CX24116 if !DVB_FE_CUSTOMISE
+        select DVB_SI21XX if !DVB_FE_CUSTOMISE
+        select DVB_TDA10023 if !DVB_FE_CUSTOMISE
+        select DVB_MT312 if !DVB_FE_CUSTOMISE
+        select DVB_ZL10039 if !DVB_FE_CUSTOMISE
+        select DVB_DS3000 if !DVB_FE_CUSTOMISE
+        select DVB_STB6100 if !DVB_FE_CUSTOMISE
+        select DVB_STV6110 if !DVB_FE_CUSTOMISE
+        select DVB_STV0900 if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the DvbWorld, TeVii, Prof DVB-S/S2 USB2.0
+          receivers.
+
+config DVB_USB_CINERGY_T2
+        tristate "Terratec CinergyT2/qanu USB 2.0 DVB-T receiver"
+        depends on DVB_USB
+        help
+          Support for "TerraTec CinergyT2" USB2.0 Highspeed DVB Receivers
+
+          Say Y if you own such a device and want to use it.
+
+config DVB_USB_ANYSEE
+        tristate "Anysee DVB-T/C USB2.0 support"
+        depends on DVB_USB
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        select DVB_MT352 if !DVB_FE_CUSTOMISE
+        select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+        select DVB_TDA10023 if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_TDA18212 if !MEDIA_TUNER_CUSTOMISE
+        select DVB_CX24116 if !DVB_FE_CUSTOMISE
+        select DVB_STV0900 if !DVB_FE_CUSTOMISE
+        select DVB_STV6110 if !DVB_FE_CUSTOMISE
+        select DVB_ISL6423 if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the Anysee E30, Anysee E30 Plus or
+          Anysee E30 C Plus DVB USB2.0 receiver.
+
+config DVB_USB_DTV5100
+        tristate "AME DTV-5100 USB2.0 DVB-T support"
+        depends on DVB_USB
+        select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_QT1010 if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the AME DTV-5100 USB2.0 DVB-T receiver.
+
+config DVB_USB_AF9015
+        tristate "Afatech AF9015 DVB-T USB2.0 support"
+        depends on DVB_USB
+        select DVB_AF9013
+        select DVB_PLL              if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_MT2060   if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_QT1010   if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_TDA18271 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_MXL5005S if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_MC44S803 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_TDA18218 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_MXL5007T if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the Afatech AF9015 based DVB-T USB2.0 receiver
+
+config DVB_USB_CE6230
+        tristate "Intel CE6230 DVB-T USB2.0 support"
+        depends on DVB_USB && EXPERIMENTAL
+        select DVB_ZL10353
+        select MEDIA_TUNER_MXL5005S if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the Intel CE6230 DVB-T USB2.0 receiver
+
+config DVB_USB_FRIIO
+        tristate "Friio ISDB-T USB2.0 Receiver support"
+        depends on DVB_USB
+        help
+          Say Y here to support the Japanese DTV receiver Friio.
+
+config DVB_USB_EC168
+        tristate "E3C EC168 DVB-T USB2.0 support"
+        depends on DVB_USB && EXPERIMENTAL
+        select DVB_EC100
+        select MEDIA_TUNER_MXL5005S if !MEDIA_TUNER_CUSTOMISE
+        help
+          Say Y here to support the E3C EC168 DVB-T USB2.0 receiver.
+
+config DVB_USB_AZ6027
+        tristate "Azurewave DVB-S/S2 USB2.0 AZ6027 support"
+        depends on DVB_USB
+        select DVB_STB0899 if !DVB_FE_CUSTOMISE
+        select DVB_STB6100 if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the AZ6027 device
+
+config DVB_USB_LME2510
+        tristate "LME DM04/QQBOX DVB-S USB2.0 support"
+        depends on DVB_USB
+        select DVB_TDA10086 if !DVB_FE_CUSTOMISE
+        select DVB_TDA826X if !DVB_FE_CUSTOMISE
+        select DVB_STV0288 if !DVB_FE_CUSTOMISE
+        select DVB_IX2505V if !DVB_FE_CUSTOMISE
+        select DVB_STV0299 if !DVB_FE_CUSTOMISE
+        select DVB_PLL if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the LME DM04/QQBOX DVB-S USB2.0 .
+
+config DVB_USB_TECHNISAT_USB2
+        tristate "Technisat DVB-S/S2 USB2.0 support"
+        depends on DVB_USB
+        select DVB_STV090x if !DVB_FE_CUSTOMISE
+        select DVB_STV6110x if !DVB_FE_CUSTOMISE
+        help
+          Say Y here to support the Technisat USB2 DVB-S/S2 device
diff --git a/drivers/media/dvb/dvb-usb/Makefile b/drivers/media/dvb/dvb-usb/Makefile
new file mode 100644
index 00000000000..4bac13da0c3
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/Makefile
@@ -0,0 +1,100 @@
+dvb-usb-objs = dvb-usb-firmware.o dvb-usb-init.o dvb-usb-urb.o dvb-usb-i2c.o dvb-usb-dvb.o dvb-usb-remote.o usb-urb.o
+obj-$(CONFIG_DVB_USB) += dvb-usb.o
+
+dvb-usb-vp7045-objs = vp7045.o vp7045-fe.o
+obj-$(CONFIG_DVB_USB_VP7045) += dvb-usb-vp7045.o
+
+dvb-usb-vp702x-objs = vp702x.o vp702x-fe.o
+obj-$(CONFIG_DVB_USB_VP702X) += dvb-usb-vp702x.o
+
+dvb-usb-gp8psk-objs = gp8psk.o gp8psk-fe.o
+obj-$(CONFIG_DVB_USB_GP8PSK) += dvb-usb-gp8psk.o
+
+dvb-usb-dtt200u-objs = dtt200u.o dtt200u-fe.o
+obj-$(CONFIG_DVB_USB_DTT200U) += dvb-usb-dtt200u.o
+
+dvb-usb-dibusb-common-objs = dibusb-common.o
+
+dvb-usb-a800-objs = a800.o
+obj-$(CONFIG_DVB_USB_A800) += dvb-usb-dibusb-common.o dvb-usb-a800.o
+
+dvb-usb-dibusb-mb-objs = dibusb-mb.o
+obj-$(CONFIG_DVB_USB_DIBUSB_MB) += dvb-usb-dibusb-common.o dvb-usb-dibusb-mb.o
+
+dvb-usb-dibusb-mc-objs = dibusb-mc.o
+obj-$(CONFIG_DVB_USB_DIBUSB_MC) += dvb-usb-dibusb-common.o dvb-usb-dibusb-mc.o
+
+dvb-usb-nova-t-usb2-objs = nova-t-usb2.o
+obj-$(CONFIG_DVB_USB_NOVA_T_USB2) += dvb-usb-dibusb-common.o dvb-usb-nova-t-usb2.o
+
+dvb-usb-umt-010-objs = umt-010.o
+obj-$(CONFIG_DVB_USB_UMT_010) += dvb-usb-dibusb-common.o dvb-usb-umt-010.o
+
+dvb-usb-m920x-objs = m920x.o
+obj-$(CONFIG_DVB_USB_M920X) += dvb-usb-m920x.o
+
+dvb-usb-gl861-objs = gl861.o
+obj-$(CONFIG_DVB_USB_GL861) += dvb-usb-gl861.o
+
+dvb-usb-au6610-objs = au6610.o
+obj-$(CONFIG_DVB_USB_AU6610) += dvb-usb-au6610.o
+
+dvb-usb-digitv-objs = digitv.o
+obj-$(CONFIG_DVB_USB_DIGITV) += dvb-usb-digitv.o
+
+dvb-usb-cxusb-objs = cxusb.o
+obj-$(CONFIG_DVB_USB_CXUSB) += dvb-usb-cxusb.o
+
+dvb-usb-ttusb2-objs = ttusb2.o
+obj-$(CONFIG_DVB_USB_TTUSB2) += dvb-usb-ttusb2.o
+
+dvb-usb-dib0700-objs = dib0700_core.o dib0700_devices.o
+obj-$(CONFIG_DVB_USB_DIB0700) += dvb-usb-dib0700.o
+
+dvb-usb-opera-objs = opera1.o
+obj-$(CONFIG_DVB_USB_OPERA1) += dvb-usb-opera.o
+
+
+dvb-usb-af9005-objs = af9005.o af9005-fe.o
+obj-$(CONFIG_DVB_USB_AF9005) += dvb-usb-af9005.o
+
+dvb-usb-af9005-remote-objs = af9005-remote.o
+obj-$(CONFIG_DVB_USB_AF9005_REMOTE) += dvb-usb-af9005-remote.o
+
+dvb-usb-anysee-objs = anysee.o
+obj-$(CONFIG_DVB_USB_ANYSEE) += dvb-usb-anysee.o
+
+dvb-usb-dw2102-objs = dw2102.o
+obj-$(CONFIG_DVB_USB_DW2102) += dvb-usb-dw2102.o
+
+dvb-usb-dtv5100-objs = dtv5100.o
+obj-$(CONFIG_DVB_USB_DTV5100) += dvb-usb-dtv5100.o
+
+dvb-usb-af9015-objs = af9015.o
+obj-$(CONFIG_DVB_USB_AF9015) += dvb-usb-af9015.o
+
+dvb-usb-cinergyT2-objs = cinergyT2-core.o cinergyT2-fe.o
+obj-$(CONFIG_DVB_USB_CINERGY_T2) += dvb-usb-cinergyT2.o
+
+dvb-usb-ce6230-objs = ce6230.o
+obj-$(CONFIG_DVB_USB_CE6230) += dvb-usb-ce6230.o
+
+dvb-usb-friio-objs = friio.o friio-fe.o
+obj-$(CONFIG_DVB_USB_FRIIO) += dvb-usb-friio.o
+
+dvb-usb-ec168-objs = ec168.o
+obj-$(CONFIG_DVB_USB_EC168) += dvb-usb-ec168.o
+
+dvb-usb-az6027-objs = az6027.o
+obj-$(CONFIG_DVB_USB_AZ6027) += dvb-usb-az6027.o
+
+dvb-usb-lmedm04-objs = lmedm04.o
+obj-$(CONFIG_DVB_USB_LME2510) += dvb-usb-lmedm04.o
+
+dvb-usb-technisat-usb2-objs = technisat-usb2.o
+obj-$(CONFIG_DVB_USB_TECHNISAT_USB2) += dvb-usb-technisat-usb2.o
+
+EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core/ -Idrivers/media/dvb/frontends/
+# due to tuner-xc3028
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
+
diff --git a/drivers/media/dvb/dvb-usb/a800.c b/drivers/media/dvb/dvb-usb/a800.c
new file mode 100644
index 00000000000..b95a95e1784
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/a800.c
@@ -0,0 +1,208 @@
+/* DVB USB framework compliant Linux driver for the AVerMedia AverTV DVB-T
+ * USB2.0 (A800) DVB-T receiver.
+ *
+ * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ * Thanks to
+ *   - AVerMedia who kindly provided information and
+ *   - Glen Harris who suffered from my mistakes during development.
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dibusb.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (rc=1 (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+#define deb_rc(args...)   dprintk(debug,0x01,args)
+
+static int a800_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        /* do nothing for the AVerMedia */
+        return 0;
+}
+
+/* assure to put cold to 0 for iManufacturer == 1 */
+static int a800_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props,
+        struct dvb_usb_device_description **desc, int *cold)
+{
+        *cold = udev->descriptor.iManufacturer != 1;
+        return 0;
+}
+
+static struct rc_map_table rc_map_a800_table[] = {
+        { 0x0201, KEY_MODE },      /* SOURCE */
+        { 0x0200, KEY_POWER2 },      /* POWER */
+        { 0x0205, KEY_1 },           /* 1 */
+        { 0x0206, KEY_2 },           /* 2 */
+        { 0x0207, KEY_3 },           /* 3 */
+        { 0x0209, KEY_4 },           /* 4 */
+        { 0x020a, KEY_5 },           /* 5 */
+        { 0x020b, KEY_6 },           /* 6 */
+        { 0x020d, KEY_7 },           /* 7 */
+        { 0x020e, KEY_8 },           /* 8 */
+        { 0x020f, KEY_9 },           /* 9 */
+        { 0x0212, KEY_LEFT },        /* L / DISPLAY */
+        { 0x0211, KEY_0 },           /* 0 */
+        { 0x0213, KEY_RIGHT },       /* R / CH RTN */
+        { 0x0217, KEY_CAMERA },      /* SNAP SHOT */
+        { 0x0210, KEY_LAST },        /* 16-CH PREV */
+        { 0x021e, KEY_VOLUMEDOWN },  /* VOL DOWN */
+        { 0x020c, KEY_ZOOM },        /* FULL SCREEN */
+        { 0x021f, KEY_VOLUMEUP },    /* VOL UP */
+        { 0x0214, KEY_MUTE },        /* MUTE */
+        { 0x0208, KEY_AUDIO },       /* AUDIO */
+        { 0x0219, KEY_RECORD },      /* RECORD */
+        { 0x0218, KEY_PLAY },        /* PLAY */
+        { 0x021b, KEY_STOP },        /* STOP */
+        { 0x021a, KEY_PLAYPAUSE },   /* TIMESHIFT / PAUSE */
+        { 0x021d, KEY_BACK },        /* << / RED */
+        { 0x021c, KEY_FORWARD },     /* >> / YELLOW */
+        { 0x0203, KEY_TEXT },        /* TELETEXT */
+        { 0x0204, KEY_EPG },         /* EPG */
+        { 0x0215, KEY_MENU },        /* MENU */
+
+        { 0x0303, KEY_CHANNELUP },   /* CH UP */
+        { 0x0302, KEY_CHANNELDOWN }, /* CH DOWN */
+        { 0x0301, KEY_FIRST },       /* |<< / GREEN */
+        { 0x0300, KEY_LAST },        /* >>| / BLUE */
+
+};
+
+static int a800_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        int ret;
+        u8 *key = kmalloc(5, GFP_KERNEL);
+        if (!key)
+                return -ENOMEM;
+
+        if (usb_control_msg(d->udev,usb_rcvctrlpipe(d->udev,0),
+                                0x04, USB_TYPE_VENDOR | USB_DIR_IN, 0, 0, key, 5,
+                                2000) != 5) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        /* call the universal NEC remote processor, to find out the key's state and event */
+        dvb_usb_nec_rc_key_to_event(d,key,event,state);
+        if (key[0] != 0)
+                deb_rc("key: %x %x %x %x %x\n",key[0],key[1],key[2],key[3],key[4]);
+        ret = 0;
+out:
+        kfree(key);
+        return ret;
+}
+
+/* USB Driver stuff */
+static struct dvb_usb_device_properties a800_properties;
+
+static int a800_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        return dvb_usb_device_init(intf, &a800_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
+}
+
+/* do not change the order of the ID table */
+static struct usb_device_id a800_table [] = {
+/* 00 */        { USB_DEVICE(USB_VID_AVERMEDIA,     USB_PID_AVERMEDIA_DVBT_USB2_COLD) },
+/* 01 */        { USB_DEVICE(USB_VID_AVERMEDIA,     USB_PID_AVERMEDIA_DVBT_USB2_WARM) },
+                        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, a800_table);
+
+static struct dvb_usb_device_properties a800_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-avertv-a800-02.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .pid_filter_count = 32,
+                        .streaming_ctrl   = dibusb2_0_streaming_ctrl,
+                        .pid_filter       = dibusb_pid_filter,
+                        .pid_filter_ctrl  = dibusb_pid_filter_ctrl,
+
+                        .frontend_attach  = dibusb_dib3000mc_frontend_attach,
+                        .tuner_attach     = dibusb_dib3000mc_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                                        .stream = {
+                                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x06,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+
+                        .size_of_priv     = sizeof(struct dibusb_state),
+                },
+        },
+
+        .power_ctrl       = a800_power_ctrl,
+        .identify_state   = a800_identify_state,
+
+        .rc.legacy = {
+                .rc_interval      = DEFAULT_RC_INTERVAL,
+                .rc_map_table     = rc_map_a800_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_a800_table),
+                .rc_query         = a800_rc_query,
+        },
+
+        .i2c_algo         = &dibusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+        .num_device_descs = 1,
+        .devices = {
+                {   "AVerMedia AverTV DVB-T USB 2.0 (A800)",
+                        { &a800_table[0], NULL },
+                        { &a800_table[1], NULL },
+                },
+        }
+};
+
+static struct usb_driver a800_driver = {
+        .name           = "dvb_usb_a800",
+        .probe          = a800_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = a800_table,
+};
+
+/* module stuff */
+static int __init a800_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&a800_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit a800_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&a800_driver);
+}
+
+module_init (a800_module_init);
+module_exit (a800_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("AVerMedia AverTV DVB-T USB 2.0 (A800)");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/af9005-fe.c b/drivers/media/dvb/dvb-usb/af9005-fe.c
new file mode 100644
index 00000000000..6ad94745bbd
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/af9005-fe.c
@@ -0,0 +1,1488 @@
+/* Frontend part of the Linux driver for the Afatech 9005
+ * USB1.1 DVB-T receiver.
+ *
+ * Copyright (C) 2007 Luca Olivetti (luca@ventoso.org)
+ *
+ * Thanks to Afatech who kindly provided information.
+ *
+ * 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.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "af9005.h"
+#include "af9005-script.h"
+#include "mt2060.h"
+#include "qt1010.h"
+#include <asm/div64.h>
+
+struct af9005_fe_state {
+        struct dvb_usb_device *d;
+        fe_status_t stat;
+
+        /* retraining parameters */
+        u32 original_fcw;
+        u16 original_rf_top;
+        u16 original_if_top;
+        u16 original_if_min;
+        u16 original_aci0_if_top;
+        u16 original_aci1_if_top;
+        u16 original_aci0_if_min;
+        u8 original_if_unplug_th;
+        u8 original_rf_unplug_th;
+        u8 original_dtop_if_unplug_th;
+        u8 original_dtop_rf_unplug_th;
+
+        /* statistics */
+        u32 pre_vit_error_count;
+        u32 pre_vit_bit_count;
+        u32 ber;
+        u32 post_vit_error_count;
+        u32 post_vit_bit_count;
+        u32 unc;
+        u16 abort_count;
+
+        int opened;
+        int strong;
+        unsigned long next_status_check;
+        struct dvb_frontend frontend;
+};
+
+static int af9005_write_word_agc(struct dvb_usb_device *d, u16 reghi,
+                                 u16 reglo, u8 pos, u8 len, u16 value)
+{
+        int ret;
+        u8 temp;
+
+        if ((ret = af9005_write_ofdm_register(d, reglo, (u8) (value & 0xff))))
+                return ret;
+        temp = (u8) ((value & 0x0300) >> 8);
+        return af9005_write_register_bits(d, reghi, pos, len,
+                                          (u8) ((value & 0x300) >> 8));
+}
+
+static int af9005_read_word_agc(struct dvb_usb_device *d, u16 reghi,
+                                u16 reglo, u8 pos, u8 len, u16 * value)
+{
+        int ret;
+        u8 temp0, temp1;
+
+        if ((ret = af9005_read_ofdm_register(d, reglo, &temp0)))
+                return ret;
+        if ((ret = af9005_read_ofdm_register(d, reghi, &temp1)))
+                return ret;
+        switch (pos) {
+        case 0:
+                *value = ((u16) (temp1 & 0x03) << 8) + (u16) temp0;
+                break;
+        case 2:
+                *value = ((u16) (temp1 & 0x0C) << 6) + (u16) temp0;
+                break;
+        case 4:
+                *value = ((u16) (temp1 & 0x30) << 4) + (u16) temp0;
+                break;
+        case 6:
+                *value = ((u16) (temp1 & 0xC0) << 2) + (u16) temp0;
+                break;
+        default:
+                err("invalid pos in read word agc");
+                return -EINVAL;
+        }
+        return 0;
+
+}
+
+static int af9005_is_fecmon_available(struct dvb_frontend *fe, int *available)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        int ret;
+        u8 temp;
+
+        *available = false;
+
+        ret = af9005_read_register_bits(state->d, xd_p_fec_vtb_rsd_mon_en,
+                                        fec_vtb_rsd_mon_en_pos,
+                                        fec_vtb_rsd_mon_en_len, &temp);
+        if (ret)
+                return ret;
+        if (temp & 1) {
+                ret =
+                    af9005_read_register_bits(state->d,
+                                              xd_p_reg_ofsm_read_rbc_en,
+                                              reg_ofsm_read_rbc_en_pos,
+                                              reg_ofsm_read_rbc_en_len, &temp);
+                if (ret)
+                        return ret;
+                if ((temp & 1) == 0)
+                        *available = true;
+
+        }
+        return 0;
+}
+
+static int af9005_get_post_vit_err_cw_count(struct dvb_frontend *fe,
+                                            u32 * post_err_count,
+                                            u32 * post_cw_count,
+                                            u16 * abort_count)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        int ret;
+        u32 err_count;
+        u32 cw_count;
+        u8 temp, temp0, temp1, temp2;
+        u16 loc_abort_count;
+
+        *post_err_count = 0;
+        *post_cw_count = 0;
+
+        /* check if error bit count is ready */
+        ret =
+            af9005_read_register_bits(state->d, xd_r_fec_rsd_ber_rdy,
+                                      fec_rsd_ber_rdy_pos, fec_rsd_ber_rdy_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        if (!temp) {
+                deb_info("rsd counter not ready\n");
+                return 100;
+        }
+        /* get abort count */
+        ret =
+            af9005_read_ofdm_register(state->d,
+                                      xd_r_fec_rsd_abort_packet_cnt_7_0,
+                                      &temp0);
+        if (ret)
+                return ret;
+        ret =
+            af9005_read_ofdm_register(state->d,
+                                      xd_r_fec_rsd_abort_packet_cnt_15_8,
+                                      &temp1);
+        if (ret)
+                return ret;
+        loc_abort_count = ((u16) temp1 << 8) + temp0;
+
+        /* get error count */
+        ret =
+            af9005_read_ofdm_register(state->d, xd_r_fec_rsd_bit_err_cnt_7_0,
+                                      &temp0);
+        if (ret)
+                return ret;
+        ret =
+            af9005_read_ofdm_register(state->d, xd_r_fec_rsd_bit_err_cnt_15_8,
+                                      &temp1);
+        if (ret)
+                return ret;
+        ret =
+            af9005_read_ofdm_register(state->d, xd_r_fec_rsd_bit_err_cnt_23_16,
+                                      &temp2);
+        if (ret)
+                return ret;
+        err_count = ((u32) temp2 << 16) + ((u32) temp1 << 8) + temp0;
+        *post_err_count = err_count - (u32) loc_abort_count *8 * 8;
+
+        /* get RSD packet number */
+        ret =
+            af9005_read_ofdm_register(state->d, xd_p_fec_rsd_packet_unit_7_0,
+                                      &temp0);
+        if (ret)
+                return ret;
+        ret =
+            af9005_read_ofdm_register(state->d, xd_p_fec_rsd_packet_unit_15_8,
+                                      &temp1);
+        if (ret)
+                return ret;
+        cw_count = ((u32) temp1 << 8) + temp0;
+        if (cw_count == 0) {
+                err("wrong RSD packet count");
+                return -EIO;
+        }
+        deb_info("POST abort count %d err count %d rsd packets %d\n",
+                 loc_abort_count, err_count, cw_count);
+        *post_cw_count = cw_count - (u32) loc_abort_count;
+        *abort_count = loc_abort_count;
+        return 0;
+
+}
+
+static int af9005_get_post_vit_ber(struct dvb_frontend *fe,
+                                   u32 * post_err_count, u32 * post_cw_count,
+                                   u16 * abort_count)
+{
+        u32 loc_cw_count = 0, loc_err_count;
+        u16 loc_abort_count = 0;
+        int ret;
+
+        ret =
+            af9005_get_post_vit_err_cw_count(fe, &loc_err_count, &loc_cw_count,
+                                             &loc_abort_count);
+        if (ret)
+                return ret;
+        *post_err_count = loc_err_count;
+        *post_cw_count = loc_cw_count * 204 * 8;
+        *abort_count = loc_abort_count;
+
+        return 0;
+}
+
+static int af9005_get_pre_vit_err_bit_count(struct dvb_frontend *fe,
+                                            u32 * pre_err_count,
+                                            u32 * pre_bit_count)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        u8 temp, temp0, temp1, temp2;
+        u32 super_frame_count, x, bits;
+        int ret;
+
+        ret =
+            af9005_read_register_bits(state->d, xd_r_fec_vtb_ber_rdy,
+                                      fec_vtb_ber_rdy_pos, fec_vtb_ber_rdy_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        if (!temp) {
+                deb_info("viterbi counter not ready\n");
+                return 101;     /* ERR_APO_VTB_COUNTER_NOT_READY; */
+        }
+        ret =
+            af9005_read_ofdm_register(state->d, xd_r_fec_vtb_err_bit_cnt_7_0,
+                                      &temp0);
+        if (ret)
+                return ret;
+        ret =
+            af9005_read_ofdm_register(state->d, xd_r_fec_vtb_err_bit_cnt_15_8,
+                                      &temp1);
+        if (ret)
+                return ret;
+        ret =
+            af9005_read_ofdm_register(state->d, xd_r_fec_vtb_err_bit_cnt_23_16,
+                                      &temp2);
+        if (ret)
+                return ret;
+        *pre_err_count = ((u32) temp2 << 16) + ((u32) temp1 << 8) + temp0;
+
+        ret =
+            af9005_read_ofdm_register(state->d, xd_p_fec_super_frm_unit_7_0,
+                                      &temp0);
+        if (ret)
+                return ret;
+        ret =
+            af9005_read_ofdm_register(state->d, xd_p_fec_super_frm_unit_15_8,
+                                      &temp1);
+        if (ret)
+                return ret;
+        super_frame_count = ((u32) temp1 << 8) + temp0;
+        if (super_frame_count == 0) {
+                deb_info("super frame count 0\n");
+                return 102;
+        }
+
+        /* read fft mode */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_tpsd_txmod,
+                                      reg_tpsd_txmod_pos, reg_tpsd_txmod_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        if (temp == 0) {
+                /* 2K */
+                x = 1512;
+        } else if (temp == 1) {
+                /* 8k */
+                x = 6048;
+        } else {
+                err("Invalid fft mode");
+                return -EINVAL;
+        }
+
+        /* read constellation mode */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_tpsd_const,
+                                      reg_tpsd_const_pos, reg_tpsd_const_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        switch (temp) {
+        case 0:         /* QPSK */
+                bits = 2;
+                break;
+        case 1:         /* QAM_16 */
+                bits = 4;
+                break;
+        case 2:         /* QAM_64 */
+                bits = 6;
+                break;
+        default:
+                err("invalid constellation mode");
+                return -EINVAL;
+        }
+        *pre_bit_count = super_frame_count * 68 * 4 * x * bits;
+        deb_info("PRE err count %d frame count %d bit count %d\n",
+                 *pre_err_count, super_frame_count, *pre_bit_count);
+        return 0;
+}
+
+static int af9005_reset_pre_viterbi(struct dvb_frontend *fe)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        int ret;
+
+        /* set super frame count to 1 */
+        ret =
+            af9005_write_ofdm_register(state->d, xd_p_fec_super_frm_unit_7_0,
+                                       1 & 0xff);
+        if (ret)
+                return ret;
+        ret = af9005_write_ofdm_register(state->d, xd_p_fec_super_frm_unit_15_8,
+                                         1 >> 8);
+        if (ret)
+                return ret;
+        /* reset pre viterbi error count */
+        ret =
+            af9005_write_register_bits(state->d, xd_p_fec_vtb_ber_rst,
+                                       fec_vtb_ber_rst_pos, fec_vtb_ber_rst_len,
+                                       1);
+
+        return ret;
+}
+
+static int af9005_reset_post_viterbi(struct dvb_frontend *fe)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        int ret;
+
+        /* set packet unit */
+        ret =
+            af9005_write_ofdm_register(state->d, xd_p_fec_rsd_packet_unit_7_0,
+                                       10000 & 0xff);
+        if (ret)
+                return ret;
+        ret =
+            af9005_write_ofdm_register(state->d, xd_p_fec_rsd_packet_unit_15_8,
+                                       10000 >> 8);
+        if (ret)
+                return ret;
+        /* reset post viterbi error count */
+        ret =
+            af9005_write_register_bits(state->d, xd_p_fec_rsd_ber_rst,
+                                       fec_rsd_ber_rst_pos, fec_rsd_ber_rst_len,
+                                       1);
+
+        return ret;
+}
+
+static int af9005_get_statistic(struct dvb_frontend *fe)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        int ret, fecavailable;
+        u64 numerator, denominator;
+
+        deb_info("GET STATISTIC\n");
+        ret = af9005_is_fecmon_available(fe, &fecavailable);
+        if (ret)
+                return ret;
+        if (!fecavailable) {
+                deb_info("fecmon not available\n");
+                return 0;
+        }
+
+        ret = af9005_get_pre_vit_err_bit_count(fe, &state->pre_vit_error_count,
+                                               &state->pre_vit_bit_count);
+        if (ret == 0) {
+                af9005_reset_pre_viterbi(fe);
+                if (state->pre_vit_bit_count > 0) {
+                        /* according to v 0.0.4 of the dvb api ber should be a multiple
+                           of 10E-9 so we have to multiply the error count by
+                           10E9=1000000000 */
+                        numerator =
+                            (u64) state->pre_vit_error_count * (u64) 1000000000;
+                        denominator = (u64) state->pre_vit_bit_count;
+                        state->ber = do_div(numerator, denominator);
+                } else {
+                        state->ber = 0xffffffff;
+                }
+        }
+
+        ret = af9005_get_post_vit_ber(fe, &state->post_vit_error_count,
+                                      &state->post_vit_bit_count,
+                                      &state->abort_count);
+        if (ret == 0) {
+                ret = af9005_reset_post_viterbi(fe);
+                state->unc += state->abort_count;
+                if (ret)
+                        return ret;
+        }
+        return 0;
+}
+
+static int af9005_fe_refresh_state(struct dvb_frontend *fe)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        if (time_after(jiffies, state->next_status_check)) {
+                deb_info("REFRESH STATE\n");
+
+                /* statistics */
+                if (af9005_get_statistic(fe))
+                        err("get_statistic_failed");
+                state->next_status_check = jiffies + 250 * HZ / 1000;
+        }
+        return 0;
+}
+
+static int af9005_fe_read_status(struct dvb_frontend *fe, fe_status_t * stat)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        u8 temp;
+        int ret;
+
+        if (fe->ops.tuner_ops.release == NULL)
+                return -ENODEV;
+
+        *stat = 0;
+        ret = af9005_read_register_bits(state->d, xd_p_agc_lock,
+                                        agc_lock_pos, agc_lock_len, &temp);
+        if (ret)
+                return ret;
+        if (temp)
+                *stat |= FE_HAS_SIGNAL;
+
+        ret = af9005_read_register_bits(state->d, xd_p_fd_tpsd_lock,
+                                        fd_tpsd_lock_pos, fd_tpsd_lock_len,
+                                        &temp);
+        if (ret)
+                return ret;
+        if (temp)
+                *stat |= FE_HAS_CARRIER;
+
+        ret = af9005_read_register_bits(state->d,
+                                        xd_r_mp2if_sync_byte_locked,
+                                        mp2if_sync_byte_locked_pos,
+                                        mp2if_sync_byte_locked_pos, &temp);
+        if (ret)
+                return ret;
+        if (temp)
+                *stat |= FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_LOCK;
+        if (state->opened)
+                af9005_led_control(state->d, *stat & FE_HAS_LOCK);
+
+        ret =
+            af9005_read_register_bits(state->d, xd_p_reg_strong_sginal_detected,
+                                      reg_strong_sginal_detected_pos,
+                                      reg_strong_sginal_detected_len, &temp);
+        if (ret)
+                return ret;
+        if (temp != state->strong) {
+                deb_info("adjust for strong signal %d\n", temp);
+                        state->strong = temp;
+        }
+        return 0;
+}
+
+static int af9005_fe_read_ber(struct dvb_frontend *fe, u32 * ber)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        if (fe->ops.tuner_ops.release  == NULL)
+                return -ENODEV;
+        af9005_fe_refresh_state(fe);
+        *ber = state->ber;
+        return 0;
+}
+
+static int af9005_fe_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        if (fe->ops.tuner_ops.release == NULL)
+                return -ENODEV;
+        af9005_fe_refresh_state(fe);
+        *unc = state->unc;
+        return 0;
+}
+
+static int af9005_fe_read_signal_strength(struct dvb_frontend *fe,
+                                          u16 * strength)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        int ret;
+        u8 if_gain, rf_gain;
+
+        if (fe->ops.tuner_ops.release == NULL)
+                return -ENODEV;
+        ret =
+            af9005_read_ofdm_register(state->d, xd_r_reg_aagc_rf_gain,
+                                      &rf_gain);
+        if (ret)
+                return ret;
+        ret =
+            af9005_read_ofdm_register(state->d, xd_r_reg_aagc_if_gain,
+                                      &if_gain);
+        if (ret)
+                return ret;
+        /* this value has no real meaning, but i don't have the tables that relate
+           the rf and if gain with the dbm, so I just scale the value */
+        *strength = (512 - rf_gain - if_gain) << 7;
+        return 0;
+}
+
+static int af9005_fe_read_snr(struct dvb_frontend *fe, u16 * snr)
+{
+        /* the snr can be derived from the ber and the constellation
+           but I don't think this kind of complex calculations belong
+           in the driver. I may be wrong.... */
+        return -ENOSYS;
+}
+
+static int af9005_fe_program_cfoe(struct dvb_usb_device *d, fe_bandwidth_t bw)
+{
+        u8 temp0, temp1, temp2, temp3, buf[4];
+        int ret;
+        u32 NS_coeff1_2048Nu;
+        u32 NS_coeff1_8191Nu;
+        u32 NS_coeff1_8192Nu;
+        u32 NS_coeff1_8193Nu;
+        u32 NS_coeff2_2k;
+        u32 NS_coeff2_8k;
+
+        switch (bw) {
+        case BANDWIDTH_6_MHZ:
+                NS_coeff1_2048Nu = 0x2ADB6DC;
+                NS_coeff1_8191Nu = 0xAB7313;
+                NS_coeff1_8192Nu = 0xAB6DB7;
+                NS_coeff1_8193Nu = 0xAB685C;
+                NS_coeff2_2k = 0x156DB6E;
+                NS_coeff2_8k = 0x55B6DC;
+                break;
+
+        case BANDWIDTH_7_MHZ:
+                NS_coeff1_2048Nu = 0x3200001;
+                NS_coeff1_8191Nu = 0xC80640;
+                NS_coeff1_8192Nu = 0xC80000;
+                NS_coeff1_8193Nu = 0xC7F9C0;
+                NS_coeff2_2k = 0x1900000;
+                NS_coeff2_8k = 0x640000;
+                break;
+
+        case BANDWIDTH_8_MHZ:
+                NS_coeff1_2048Nu = 0x3924926;
+                NS_coeff1_8191Nu = 0xE4996E;
+                NS_coeff1_8192Nu = 0xE49249;
+                NS_coeff1_8193Nu = 0xE48B25;
+                NS_coeff2_2k = 0x1C92493;
+                NS_coeff2_8k = 0x724925;
+                break;
+        default:
+                err("Invalid bandwidth %d.", bw);
+                return -EINVAL;
+        }
+
+        /*
+         *  write NS_coeff1_2048Nu
+         */
+
+        temp0 = (u8) (NS_coeff1_2048Nu & 0x000000FF);
+        temp1 = (u8) ((NS_coeff1_2048Nu & 0x0000FF00) >> 8);
+        temp2 = (u8) ((NS_coeff1_2048Nu & 0x00FF0000) >> 16);
+        temp3 = (u8) ((NS_coeff1_2048Nu & 0x03000000) >> 24);
+
+        /*  big endian to make 8051 happy */
+        buf[0] = temp3;
+        buf[1] = temp2;
+        buf[2] = temp1;
+        buf[3] = temp0;
+
+        /*  cfoe_NS_2k_coeff1_25_24 */
+        ret = af9005_write_ofdm_register(d, 0xAE00, buf[0]);
+        if (ret)
+                return ret;
+
+        /*  cfoe_NS_2k_coeff1_23_16 */
+        ret = af9005_write_ofdm_register(d, 0xAE01, buf[1]);
+        if (ret)
+                return ret;
+
+        /*  cfoe_NS_2k_coeff1_15_8 */
+        ret = af9005_write_ofdm_register(d, 0xAE02, buf[2]);
+        if (ret)
+                return ret;
+
+        /*  cfoe_NS_2k_coeff1_7_0 */
+        ret = af9005_write_ofdm_register(d, 0xAE03, buf[3]);
+        if (ret)
+                return ret;
+
+        /*
+         *  write NS_coeff2_2k
+         */
+
+        temp0 = (u8) ((NS_coeff2_2k & 0x0000003F));
+        temp1 = (u8) ((NS_coeff2_2k & 0x00003FC0) >> 6);
+        temp2 = (u8) ((NS_coeff2_2k & 0x003FC000) >> 14);
+        temp3 = (u8) ((NS_coeff2_2k & 0x01C00000) >> 22);
+
+        /*  big endian to make 8051 happy */
+        buf[0] = temp3;
+        buf[1] = temp2;
+        buf[2] = temp1;
+        buf[3] = temp0;
+
+        ret = af9005_write_ofdm_register(d, 0xAE04, buf[0]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE05, buf[1]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE06, buf[2]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE07, buf[3]);
+        if (ret)
+                return ret;
+
+        /*
+         *  write NS_coeff1_8191Nu
+         */
+
+        temp0 = (u8) ((NS_coeff1_8191Nu & 0x000000FF));
+        temp1 = (u8) ((NS_coeff1_8191Nu & 0x0000FF00) >> 8);
+        temp2 = (u8) ((NS_coeff1_8191Nu & 0x00FFC000) >> 16);
+        temp3 = (u8) ((NS_coeff1_8191Nu & 0x03000000) >> 24);
+
+        /*  big endian to make 8051 happy */
+        buf[0] = temp3;
+        buf[1] = temp2;
+        buf[2] = temp1;
+        buf[3] = temp0;
+
+        ret = af9005_write_ofdm_register(d, 0xAE08, buf[0]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE09, buf[1]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE0A, buf[2]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE0B, buf[3]);
+        if (ret)
+                return ret;
+
+        /*
+         *  write NS_coeff1_8192Nu
+         */
+
+        temp0 = (u8) (NS_coeff1_8192Nu & 0x000000FF);
+        temp1 = (u8) ((NS_coeff1_8192Nu & 0x0000FF00) >> 8);
+        temp2 = (u8) ((NS_coeff1_8192Nu & 0x00FFC000) >> 16);
+        temp3 = (u8) ((NS_coeff1_8192Nu & 0x03000000) >> 24);
+
+        /*  big endian to make 8051 happy */
+        buf[0] = temp3;
+        buf[1] = temp2;
+        buf[2] = temp1;
+        buf[3] = temp0;
+
+        ret = af9005_write_ofdm_register(d, 0xAE0C, buf[0]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE0D, buf[1]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE0E, buf[2]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE0F, buf[3]);
+        if (ret)
+                return ret;
+
+        /*
+         *  write NS_coeff1_8193Nu
+         */
+
+        temp0 = (u8) ((NS_coeff1_8193Nu & 0x000000FF));
+        temp1 = (u8) ((NS_coeff1_8193Nu & 0x0000FF00) >> 8);
+        temp2 = (u8) ((NS_coeff1_8193Nu & 0x00FFC000) >> 16);
+        temp3 = (u8) ((NS_coeff1_8193Nu & 0x03000000) >> 24);
+
+        /*  big endian to make 8051 happy */
+        buf[0] = temp3;
+        buf[1] = temp2;
+        buf[2] = temp1;
+        buf[3] = temp0;
+
+        ret = af9005_write_ofdm_register(d, 0xAE10, buf[0]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE11, buf[1]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE12, buf[2]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE13, buf[3]);
+        if (ret)
+                return ret;
+
+        /*
+         *  write NS_coeff2_8k
+         */
+
+        temp0 = (u8) ((NS_coeff2_8k & 0x0000003F));
+        temp1 = (u8) ((NS_coeff2_8k & 0x00003FC0) >> 6);
+        temp2 = (u8) ((NS_coeff2_8k & 0x003FC000) >> 14);
+        temp3 = (u8) ((NS_coeff2_8k & 0x01C00000) >> 22);
+
+        /*  big endian to make 8051 happy */
+        buf[0] = temp3;
+        buf[1] = temp2;
+        buf[2] = temp1;
+        buf[3] = temp0;
+
+        ret = af9005_write_ofdm_register(d, 0xAE14, buf[0]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE15, buf[1]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE16, buf[2]);
+        if (ret)
+                return ret;
+
+        ret = af9005_write_ofdm_register(d, 0xAE17, buf[3]);
+        return ret;
+
+}
+
+static int af9005_fe_select_bw(struct dvb_usb_device *d, fe_bandwidth_t bw)
+{
+        u8 temp;
+        switch (bw) {
+        case BANDWIDTH_6_MHZ:
+                temp = 0;
+                break;
+        case BANDWIDTH_7_MHZ:
+                temp = 1;
+                break;
+        case BANDWIDTH_8_MHZ:
+                temp = 2;
+                break;
+        default:
+                err("Invalid bandwidth %d.", bw);
+                return -EINVAL;
+        }
+        return af9005_write_register_bits(d, xd_g_reg_bw, reg_bw_pos,
+                                          reg_bw_len, temp);
+}
+
+static int af9005_fe_power(struct dvb_frontend *fe, int on)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        u8 temp = on;
+        int ret;
+        deb_info("power %s tuner\n", on ? "on" : "off");
+        ret = af9005_send_command(state->d, 0x03, &temp, 1, NULL, 0);
+        return ret;
+}
+
+static struct mt2060_config af9005_mt2060_config = {
+        0xC0
+};
+
+static struct qt1010_config af9005_qt1010_config = {
+        0xC4
+};
+
+static int af9005_fe_init(struct dvb_frontend *fe)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        int ret, i, scriptlen;
+        u8 temp, temp0 = 0, temp1 = 0, temp2 = 0;
+        u8 buf[2];
+        u16 if1;
+
+        deb_info("in af9005_fe_init\n");
+
+        /* reset */
+        deb_info("reset\n");
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_I2C_reg_ofdm_rst_en,
+                                        4, 1, 0x01)))
+                return ret;
+        if ((ret = af9005_write_ofdm_register(state->d, APO_REG_RESET, 0)))
+                return ret;
+        /* clear ofdm reset */
+        deb_info("clear ofdm reset\n");
+        for (i = 0; i < 150; i++) {
+                if ((ret =
+                     af9005_read_ofdm_register(state->d,
+                                               xd_I2C_reg_ofdm_rst, &temp)))
+                        return ret;
+                if (temp & (regmask[reg_ofdm_rst_len - 1] << reg_ofdm_rst_pos))
+                        break;
+                msleep(10);
+        }
+        if (i == 150)
+                return -ETIMEDOUT;
+
+        /*FIXME in the dump
+           write B200 A9
+           write xd_g_reg_ofsm_clk 7
+           read eepr c6 (2)
+           read eepr c7 (2)
+           misc ctrl 3 -> 1
+           read eepr ca (6)
+           write xd_g_reg_ofsm_clk 0
+           write B200 a1
+         */
+        ret = af9005_write_ofdm_register(state->d, 0xb200, 0xa9);
+        if (ret)
+                return ret;
+        ret = af9005_write_ofdm_register(state->d, xd_g_reg_ofsm_clk, 0x07);
+        if (ret)
+                return ret;
+        temp = 0x01;
+        ret = af9005_send_command(state->d, 0x03, &temp, 1, NULL, 0);
+        if (ret)
+                return ret;
+        ret = af9005_write_ofdm_register(state->d, xd_g_reg_ofsm_clk, 0x00);
+        if (ret)
+                return ret;
+        ret = af9005_write_ofdm_register(state->d, 0xb200, 0xa1);
+        if (ret)
+                return ret;
+
+        temp = regmask[reg_ofdm_rst_len - 1] << reg_ofdm_rst_pos;
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_I2C_reg_ofdm_rst,
+                                        reg_ofdm_rst_pos, reg_ofdm_rst_len, 1)))
+                return ret;
+        ret = af9005_write_register_bits(state->d, xd_I2C_reg_ofdm_rst,
+                                         reg_ofdm_rst_pos, reg_ofdm_rst_len, 0);
+
+        if (ret)
+                return ret;
+        /* don't know what register aefc is, but this is what the windows driver does */
+        ret = af9005_write_ofdm_register(state->d, 0xaefc, 0);
+        if (ret)
+                return ret;
+
+        /* set stand alone chip */
+        deb_info("set stand alone chip\n");
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_p_reg_dca_stand_alone,
+                                        reg_dca_stand_alone_pos,
+                                        reg_dca_stand_alone_len, 1)))
+                return ret;
+
+        /* set dca upper & lower chip */
+        deb_info("set dca upper & lower chip\n");
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_p_reg_dca_upper_chip,
+                                        reg_dca_upper_chip_pos,
+                                        reg_dca_upper_chip_len, 0)))
+                return ret;
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_p_reg_dca_lower_chip,
+                                        reg_dca_lower_chip_pos,
+                                        reg_dca_lower_chip_len, 0)))
+                return ret;
+
+        /* set 2wire master clock to 0x14 (for 60KHz) */
+        deb_info("set 2wire master clock to 0x14 (for 60KHz)\n");
+        if ((ret =
+             af9005_write_ofdm_register(state->d, xd_I2C_i2c_m_period, 0x14)))
+                return ret;
+
+        /* clear dca enable chip */
+        deb_info("clear dca enable chip\n");
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_p_reg_dca_en,
+                                        reg_dca_en_pos, reg_dca_en_len, 0)))
+                return ret;
+        /* FIXME these are register bits, but I don't know which ones */
+        ret = af9005_write_ofdm_register(state->d, 0xa16c, 1);
+        if (ret)
+                return ret;
+        ret = af9005_write_ofdm_register(state->d, 0xa3c1, 0);
+        if (ret)
+                return ret;
+
+        /* init other parameters: program cfoe and select bandwidth */
+        deb_info("program cfoe\n");
+        if ((ret = af9005_fe_program_cfoe(state->d, BANDWIDTH_6_MHZ)))
+                return ret;
+        /* set read-update bit for constellation */
+        deb_info("set read-update bit for constellation\n");
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_p_reg_feq_read_update,
+                                        reg_feq_read_update_pos,
+                                        reg_feq_read_update_len, 1)))
+                return ret;
+
+        /* sample code has a set MPEG TS code here
+           but sniffing reveals that it doesn't do it */
+
+        /* set read-update bit to 1 for DCA constellation */
+        deb_info("set read-update bit 1 for DCA constellation\n");
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_p_reg_dca_read_update,
+                                        reg_dca_read_update_pos,
+                                        reg_dca_read_update_len, 1)))
+                return ret;
+
+        /* enable fec monitor */
+        deb_info("enable fec monitor\n");
+        if ((ret =
+             af9005_write_register_bits(state->d, xd_p_fec_vtb_rsd_mon_en,
+                                        fec_vtb_rsd_mon_en_pos,
+                                        fec_vtb_rsd_mon_en_len, 1)))
+                return ret;
+
+        /* FIXME should be register bits, I don't know which ones */
+        ret = af9005_write_ofdm_register(state->d, 0xa601, 0);
+
+        /* set api_retrain_never_freeze */
+        deb_info("set api_retrain_never_freeze\n");
+        if ((ret = af9005_write_ofdm_register(state->d, 0xaefb, 0x01)))
+                return ret;
+
+        /* load init script */
+        deb_info("load init script\n");
+        scriptlen = sizeof(script) / sizeof(RegDesc);
+        for (i = 0; i < scriptlen; i++) {
+                if ((ret =
+                     af9005_write_register_bits(state->d, script[i].reg,
+                                                script[i].pos,
+                                                script[i].len, script[i].val)))
+                        return ret;
+                /* save 3 bytes of original fcw */
+                if (script[i].reg == 0xae18)
+                        temp2 = script[i].val;
+                if (script[i].reg == 0xae19)
+                        temp1 = script[i].val;
+                if (script[i].reg == 0xae1a)
+                        temp0 = script[i].val;
+
+                /* save original unplug threshold */
+                if (script[i].reg == xd_p_reg_unplug_th)
+                        state->original_if_unplug_th = script[i].val;
+                if (script[i].reg == xd_p_reg_unplug_rf_gain_th)
+                        state->original_rf_unplug_th = script[i].val;
+                if (script[i].reg == xd_p_reg_unplug_dtop_if_gain_th)
+                        state->original_dtop_if_unplug_th = script[i].val;
+                if (script[i].reg == xd_p_reg_unplug_dtop_rf_gain_th)
+                        state->original_dtop_rf_unplug_th = script[i].val;
+
+        }
+        state->original_fcw =
+            ((u32) temp2 << 16) + ((u32) temp1 << 8) + (u32) temp0;
+
+
+        /* save original TOPs */
+        deb_info("save original TOPs\n");
+
+        /*  RF TOP */
+        ret =
+            af9005_read_word_agc(state->d,
+                                 xd_p_reg_aagc_rf_top_numerator_9_8,
+                                 xd_p_reg_aagc_rf_top_numerator_7_0, 0, 2,
+                                 &state->original_rf_top);
+        if (ret)
+                return ret;
+
+        /*  IF TOP */
+        ret =
+            af9005_read_word_agc(state->d,
+                                 xd_p_reg_aagc_if_top_numerator_9_8,
+                                 xd_p_reg_aagc_if_top_numerator_7_0, 0, 2,
+                                 &state->original_if_top);
+        if (ret)
+                return ret;
+
+        /*  ACI 0 IF TOP */
+        ret =
+            af9005_read_word_agc(state->d, 0xA60E, 0xA60A, 4, 2,
+                                 &state->original_aci0_if_top);
+        if (ret)
+                return ret;
+
+        /*  ACI 1 IF TOP */
+        ret =
+            af9005_read_word_agc(state->d, 0xA60E, 0xA60B, 6, 2,
+                                 &state->original_aci1_if_top);
+        if (ret)
+                return ret;
+
+        /* attach tuner and init */
+        if (fe->ops.tuner_ops.release == NULL) {
+                /* read tuner and board id from eeprom */
+                ret = af9005_read_eeprom(adap->dev, 0xc6, buf, 2);
+                if (ret) {
+                        err("Impossible to read EEPROM\n");
+                        return ret;
+                }
+                deb_info("Tuner id %d, board id %d\n", buf[0], buf[1]);
+                switch (buf[0]) {
+                case 2: /* MT2060 */
+                        /* read if1 from eeprom */
+                        ret = af9005_read_eeprom(adap->dev, 0xc8, buf, 2);
+                        if (ret) {
+                                err("Impossible to read EEPROM\n");
+                                return ret;
+                        }
+                        if1 = (u16) (buf[0] << 8) + buf[1];
+                        if (dvb_attach(mt2060_attach, fe, &adap->dev->i2c_adap,
+                                         &af9005_mt2060_config, if1) == NULL) {
+                                deb_info("MT2060 attach failed\n");
+                                return -ENODEV;
+                        }
+                        break;
+                case 3: /* QT1010 */
+                case 9: /* QT1010B */
+                        if (dvb_attach(qt1010_attach, fe, &adap->dev->i2c_adap,
+                                        &af9005_qt1010_config) ==NULL) {
+                                deb_info("QT1010 attach failed\n");
+                                return -ENODEV;
+                        }
+                        break;
+                default:
+                        err("Unsupported tuner type %d", buf[0]);
+                        return -ENODEV;
+                }
+                ret = fe->ops.tuner_ops.init(fe);
+                if (ret)
+                        return ret;
+        }
+
+        deb_info("profit!\n");
+        return 0;
+}
+
+static int af9005_fe_sleep(struct dvb_frontend *fe)
+{
+        return af9005_fe_power(fe, 0);
+}
+
+static int af9005_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+
+        if (acquire) {
+                state->opened++;
+        } else {
+
+                state->opened--;
+                if (!state->opened)
+                        af9005_led_control(state->d, 0);
+        }
+        return 0;
+}
+
+static int af9005_fe_set_frontend(struct dvb_frontend *fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        int ret;
+        u8 temp, temp0, temp1, temp2;
+
+        deb_info("af9005_fe_set_frontend freq %d bw %d\n", fep->frequency,
+                 fep->u.ofdm.bandwidth);
+        if (fe->ops.tuner_ops.release == NULL) {
+                err("Tuner not attached");
+                return -ENODEV;
+        }
+
+        deb_info("turn off led\n");
+        /* not in the log */
+        ret = af9005_led_control(state->d, 0);
+        if (ret)
+                return ret;
+        /* not sure about the bits */
+        ret = af9005_write_register_bits(state->d, XD_MP2IF_MISC, 2, 1, 0);
+        if (ret)
+                return ret;
+
+        /* set FCW to default value */
+        deb_info("set FCW to default value\n");
+        temp0 = (u8) (state->original_fcw & 0x000000ff);
+        temp1 = (u8) ((state->original_fcw & 0x0000ff00) >> 8);
+        temp2 = (u8) ((state->original_fcw & 0x00ff0000) >> 16);
+        ret = af9005_write_ofdm_register(state->d, 0xae1a, temp0);
+        if (ret)
+                return ret;
+        ret = af9005_write_ofdm_register(state->d, 0xae19, temp1);
+        if (ret)
+                return ret;
+        ret = af9005_write_ofdm_register(state->d, 0xae18, temp2);
+        if (ret)
+                return ret;
+
+        /* restore original TOPs */
+        deb_info("restore original TOPs\n");
+        ret =
+            af9005_write_word_agc(state->d,
+                                  xd_p_reg_aagc_rf_top_numerator_9_8,
+                                  xd_p_reg_aagc_rf_top_numerator_7_0, 0, 2,
+                                  state->original_rf_top);
+        if (ret)
+                return ret;
+        ret =
+            af9005_write_word_agc(state->d,
+                                  xd_p_reg_aagc_if_top_numerator_9_8,
+                                  xd_p_reg_aagc_if_top_numerator_7_0, 0, 2,
+                                  state->original_if_top);
+        if (ret)
+                return ret;
+        ret =
+            af9005_write_word_agc(state->d, 0xA60E, 0xA60A, 4, 2,
+                                  state->original_aci0_if_top);
+        if (ret)
+                return ret;
+        ret =
+            af9005_write_word_agc(state->d, 0xA60E, 0xA60B, 6, 2,
+                                  state->original_aci1_if_top);
+        if (ret)
+                return ret;
+
+        /* select bandwidth */
+        deb_info("select bandwidth");
+        ret = af9005_fe_select_bw(state->d, fep->u.ofdm.bandwidth);
+        if (ret)
+                return ret;
+        ret = af9005_fe_program_cfoe(state->d, fep->u.ofdm.bandwidth);
+        if (ret)
+                return ret;
+
+        /* clear easy mode flag */
+        deb_info("clear easy mode flag\n");
+        ret = af9005_write_ofdm_register(state->d, 0xaefd, 0);
+        if (ret)
+                return ret;
+
+        /* set unplug threshold to original value */
+        deb_info("set unplug threshold to original value\n");
+        ret =
+            af9005_write_ofdm_register(state->d, xd_p_reg_unplug_th,
+                                       state->original_if_unplug_th);
+        if (ret)
+                return ret;
+        /* set tuner */
+        deb_info("set tuner\n");
+        ret = fe->ops.tuner_ops.set_params(fe, fep);
+        if (ret)
+                return ret;
+
+        /* trigger ofsm */
+        deb_info("trigger ofsm\n");
+        temp = 0;
+        ret = af9005_write_tuner_registers(state->d, 0xffff, &temp, 1);
+        if (ret)
+                return ret;
+
+        /* clear retrain and freeze flag */
+        deb_info("clear retrain and freeze flag\n");
+        ret =
+            af9005_write_register_bits(state->d,
+                                       xd_p_reg_api_retrain_request,
+                                       reg_api_retrain_request_pos, 2, 0);
+        if (ret)
+                return ret;
+
+        /* reset pre viterbi and post viterbi registers and statistics */
+        af9005_reset_pre_viterbi(fe);
+        af9005_reset_post_viterbi(fe);
+        state->pre_vit_error_count = 0;
+        state->pre_vit_bit_count = 0;
+        state->ber = 0;
+        state->post_vit_error_count = 0;
+        /* state->unc = 0; commented out since it should be ever increasing */
+        state->abort_count = 0;
+
+        state->next_status_check = jiffies;
+        state->strong = -1;
+
+        return 0;
+}
+
+static int af9005_fe_get_frontend(struct dvb_frontend *fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct af9005_fe_state *state = fe->demodulator_priv;
+        int ret;
+        u8 temp;
+
+        /* mode */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_tpsd_const,
+                                      reg_tpsd_const_pos, reg_tpsd_const_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        deb_info("===== fe_get_frontend ==============\n");
+        deb_info("CONSTELLATION ");
+        switch (temp) {
+        case 0:
+                fep->u.ofdm.constellation = QPSK;
+                deb_info("QPSK\n");
+                break;
+        case 1:
+                fep->u.ofdm.constellation = QAM_16;
+                deb_info("QAM_16\n");
+                break;
+        case 2:
+                fep->u.ofdm.constellation = QAM_64;
+                deb_info("QAM_64\n");
+                break;
+        }
+
+        /* tps hierarchy and alpha value */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_tpsd_hier,
+                                      reg_tpsd_hier_pos, reg_tpsd_hier_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        deb_info("HIERARCHY ");
+        switch (temp) {
+        case 0:
+                fep->u.ofdm.hierarchy_information = HIERARCHY_NONE;
+                deb_info("NONE\n");
+                break;
+        case 1:
+                fep->u.ofdm.hierarchy_information = HIERARCHY_1;
+                deb_info("1\n");
+                break;
+        case 2:
+                fep->u.ofdm.hierarchy_information = HIERARCHY_2;
+                deb_info("2\n");
+                break;
+        case 3:
+                fep->u.ofdm.hierarchy_information = HIERARCHY_4;
+                deb_info("4\n");
+                break;
+        }
+
+        /*  high/low priority     */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_dec_pri,
+                                      reg_dec_pri_pos, reg_dec_pri_len, &temp);
+        if (ret)
+                return ret;
+        /* if temp is set = high priority */
+        deb_info("PRIORITY %s\n", temp ? "high" : "low");
+
+        /* high coderate */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_tpsd_hpcr,
+                                      reg_tpsd_hpcr_pos, reg_tpsd_hpcr_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        deb_info("CODERATE HP ");
+        switch (temp) {
+        case 0:
+                fep->u.ofdm.code_rate_HP = FEC_1_2;
+                deb_info("FEC_1_2\n");
+                break;
+        case 1:
+                fep->u.ofdm.code_rate_HP = FEC_2_3;
+                deb_info("FEC_2_3\n");
+                break;
+        case 2:
+                fep->u.ofdm.code_rate_HP = FEC_3_4;
+                deb_info("FEC_3_4\n");
+                break;
+        case 3:
+                fep->u.ofdm.code_rate_HP = FEC_5_6;
+                deb_info("FEC_5_6\n");
+                break;
+        case 4:
+                fep->u.ofdm.code_rate_HP = FEC_7_8;
+                deb_info("FEC_7_8\n");
+                break;
+        }
+
+        /* low coderate */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_tpsd_lpcr,
+                                      reg_tpsd_lpcr_pos, reg_tpsd_lpcr_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        deb_info("CODERATE LP ");
+        switch (temp) {
+        case 0:
+                fep->u.ofdm.code_rate_LP = FEC_1_2;
+                deb_info("FEC_1_2\n");
+                break;
+        case 1:
+                fep->u.ofdm.code_rate_LP = FEC_2_3;
+                deb_info("FEC_2_3\n");
+                break;
+        case 2:
+                fep->u.ofdm.code_rate_LP = FEC_3_4;
+                deb_info("FEC_3_4\n");
+                break;
+        case 3:
+                fep->u.ofdm.code_rate_LP = FEC_5_6;
+                deb_info("FEC_5_6\n");
+                break;
+        case 4:
+                fep->u.ofdm.code_rate_LP = FEC_7_8;
+                deb_info("FEC_7_8\n");
+                break;
+        }
+
+        /* guard interval */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_tpsd_gi,
+                                      reg_tpsd_gi_pos, reg_tpsd_gi_len, &temp);
+        if (ret)
+                return ret;
+        deb_info("GUARD INTERVAL ");
+        switch (temp) {
+        case 0:
+                fep->u.ofdm.guard_interval = GUARD_INTERVAL_1_32;
+                deb_info("1_32\n");
+                break;
+        case 1:
+                fep->u.ofdm.guard_interval = GUARD_INTERVAL_1_16;
+                deb_info("1_16\n");
+                break;
+        case 2:
+                fep->u.ofdm.guard_interval = GUARD_INTERVAL_1_8;
+                deb_info("1_8\n");
+                break;
+        case 3:
+                fep->u.ofdm.guard_interval = GUARD_INTERVAL_1_4;
+                deb_info("1_4\n");
+                break;
+        }
+
+        /* fft */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_tpsd_txmod,
+                                      reg_tpsd_txmod_pos, reg_tpsd_txmod_len,
+                                      &temp);
+        if (ret)
+                return ret;
+        deb_info("TRANSMISSION MODE ");
+        switch (temp) {
+        case 0:
+                fep->u.ofdm.transmission_mode = TRANSMISSION_MODE_2K;
+                deb_info("2K\n");
+                break;
+        case 1:
+                fep->u.ofdm.transmission_mode = TRANSMISSION_MODE_8K;
+                deb_info("8K\n");
+                break;
+        }
+
+        /* bandwidth      */
+        ret =
+            af9005_read_register_bits(state->d, xd_g_reg_bw, reg_bw_pos,
+                                      reg_bw_len, &temp);
+        deb_info("BANDWIDTH ");
+        switch (temp) {
+        case 0:
+                fep->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
+                deb_info("6\n");
+                break;
+        case 1:
+                fep->u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
+                deb_info("7\n");
+                break;
+        case 2:
+                fep->u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
+                deb_info("8\n");
+                break;
+        }
+        return 0;
+}
+
+static void af9005_fe_release(struct dvb_frontend *fe)
+{
+        struct af9005_fe_state *state =
+            (struct af9005_fe_state *)fe->demodulator_priv;
+        kfree(state);
+}
+
+static struct dvb_frontend_ops af9005_fe_ops;
+
+struct dvb_frontend *af9005_fe_attach(struct dvb_usb_device *d)
+{
+        struct af9005_fe_state *state = NULL;
+
+        /* allocate memory for the internal state */
+        state = kzalloc(sizeof(struct af9005_fe_state), GFP_KERNEL);
+        if (state == NULL)
+                goto error;
+
+        deb_info("attaching frontend af9005\n");
+
+        state->d = d;
+        state->opened = 0;
+
+        memcpy(&state->frontend.ops, &af9005_fe_ops,
+               sizeof(struct dvb_frontend_ops));
+        state->frontend.demodulator_priv = state;
+
+        return &state->frontend;
+      error:
+        return NULL;
+}
+
+static struct dvb_frontend_ops af9005_fe_ops = {
+        .info = {
+                 .name = "AF9005 USB DVB-T",
+                 .type = FE_OFDM,
+                 .frequency_min = 44250000,
+                 .frequency_max = 867250000,
+                 .frequency_stepsize = 250000,
+                 .caps = FE_CAN_INVERSION_AUTO |
+                 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
+                 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
+                 FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
+                 FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER |
+                 FE_CAN_HIERARCHY_AUTO,
+                 },
+
+        .release = af9005_fe_release,
+
+        .init = af9005_fe_init,
+        .sleep = af9005_fe_sleep,
+        .ts_bus_ctrl = af9005_ts_bus_ctrl,
+
+        .set_frontend = af9005_fe_set_frontend,
+        .get_frontend = af9005_fe_get_frontend,
+
+        .read_status = af9005_fe_read_status,
+        .read_ber = af9005_fe_read_ber,
+        .read_signal_strength = af9005_fe_read_signal_strength,
+        .read_snr = af9005_fe_read_snr,
+        .read_ucblocks = af9005_fe_read_unc_blocks,
+};
diff --git a/drivers/media/dvb/dvb-usb/af9005-remote.c b/drivers/media/dvb/dvb-usb/af9005-remote.c
new file mode 100644
index 00000000000..c3bc64ed405
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/af9005-remote.c
@@ -0,0 +1,157 @@
+/* DVB USB compliant Linux driver for the Afatech 9005
+ * USB1.1 DVB-T receiver.
+ *
+ * Standard remote decode function
+ *
+ * Copyright (C) 2007 Luca Olivetti (luca@ventoso.org)
+ *
+ * Thanks to Afatech who kindly provided information.
+ *
+ * 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.
+ *
+ * see Documentation/dvb/REDME.dvb-usb for more information
+ */
+#include "af9005.h"
+/* debug */
+static int dvb_usb_af9005_remote_debug;
+module_param_named(debug, dvb_usb_af9005_remote_debug, int, 0644);
+MODULE_PARM_DESC(debug,
+                 "enable (1) or disable (0) debug messages."
+                 DVB_USB_DEBUG_STATUS);
+
+#define deb_decode(args...)   dprintk(dvb_usb_af9005_remote_debug,0x01,args)
+
+struct rc_map_table rc_map_af9005_table[] = {
+
+        {0x01b7, KEY_POWER},
+        {0x01a7, KEY_VOLUMEUP},
+        {0x0187, KEY_CHANNELUP},
+        {0x017f, KEY_MUTE},
+        {0x01bf, KEY_VOLUMEDOWN},
+        {0x013f, KEY_CHANNELDOWN},
+        {0x01df, KEY_1},
+        {0x015f, KEY_2},
+        {0x019f, KEY_3},
+        {0x011f, KEY_4},
+        {0x01ef, KEY_5},
+        {0x016f, KEY_6},
+        {0x01af, KEY_7},
+        {0x0127, KEY_8},
+        {0x0107, KEY_9},
+        {0x01cf, KEY_ZOOM},
+        {0x014f, KEY_0},
+        {0x018f, KEY_GOTO},     /* marked jump on the remote */
+
+        {0x00bd, KEY_POWER},
+        {0x007d, KEY_VOLUMEUP},
+        {0x00fd, KEY_CHANNELUP},
+        {0x009d, KEY_MUTE},
+        {0x005d, KEY_VOLUMEDOWN},
+        {0x00dd, KEY_CHANNELDOWN},
+        {0x00ad, KEY_1},
+        {0x006d, KEY_2},
+        {0x00ed, KEY_3},
+        {0x008d, KEY_4},
+        {0x004d, KEY_5},
+        {0x00cd, KEY_6},
+        {0x00b5, KEY_7},
+        {0x0075, KEY_8},
+        {0x00f5, KEY_9},
+        {0x0095, KEY_ZOOM},
+        {0x0055, KEY_0},
+        {0x00d5, KEY_GOTO},     /* marked jump on the remote */
+};
+
+int rc_map_af9005_table_size = ARRAY_SIZE(rc_map_af9005_table);
+
+static int repeatable_keys[] = {
+        KEY_VOLUMEUP,
+        KEY_VOLUMEDOWN,
+        KEY_CHANNELUP,
+        KEY_CHANNELDOWN
+};
+
+int af9005_rc_decode(struct dvb_usb_device *d, u8 * data, int len, u32 * event,
+                     int *state)
+{
+        u16 mark, space;
+        u32 result;
+        u8 cust, dat, invdat;
+        int i;
+
+        if (len >= 6) {
+                mark = (u16) (data[0] << 8) + data[1];
+                space = (u16) (data[2] << 8) + data[3];
+                if (space * 3 < mark) {
+                        for (i = 0; i < ARRAY_SIZE(repeatable_keys); i++) {
+                                if (d->last_event == repeatable_keys[i]) {
+                                        *state = REMOTE_KEY_REPEAT;
+                                        *event = d->last_event;
+                                        deb_decode("repeat key, event %x\n",
+                                                   *event);
+                                        return 0;
+                                }
+                        }
+                        deb_decode("repeated key ignored (non repeatable)\n");
+                        return 0;
+                } else if (len >= 33 * 4) {     /*32 bits + start code */
+                        result = 0;
+                        for (i = 4; i < 4 + 32 * 4; i += 4) {
+                                result <<= 1;
+                                mark = (u16) (data[i] << 8) + data[i + 1];
+                                mark >>= 1;
+                                space = (u16) (data[i + 2] << 8) + data[i + 3];
+                                space >>= 1;
+                                if (mark * 2 > space)
+                                        result += 1;
+                        }
+                        deb_decode("key pressed, raw value %x\n", result);
+                        if ((result & 0xff000000) != 0xfe000000) {
+                                deb_decode
+                                    ("doesn't start with 0xfe, ignored\n");
+                                return 0;
+                        }
+                        cust = (result >> 16) & 0xff;
+                        dat = (result >> 8) & 0xff;
+                        invdat = (~result) & 0xff;
+                        if (dat != invdat) {
+                                deb_decode("code != inverted code\n");
+                                return 0;
+                        }
+                        for (i = 0; i < rc_map_af9005_table_size; i++) {
+                                if (rc5_custom(&rc_map_af9005_table[i]) == cust
+                                    && rc5_data(&rc_map_af9005_table[i]) == dat) {
+                                        *event = rc_map_af9005_table[i].keycode;
+                                        *state = REMOTE_KEY_PRESSED;
+                                        deb_decode
+                                            ("key pressed, event %x\n", *event);
+                                        return 0;
+                                }
+                        }
+                        deb_decode("not found in table\n");
+                }
+        }
+        return 0;
+}
+
+EXPORT_SYMBOL(rc_map_af9005_table);
+EXPORT_SYMBOL(rc_map_af9005_table_size);
+EXPORT_SYMBOL(af9005_rc_decode);
+
+MODULE_AUTHOR("Luca Olivetti <luca@ventoso.org>");
+MODULE_DESCRIPTION
+    ("Standard remote control decoder for Afatech 9005 DVB-T USB1.1 stick");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/af9005-script.h b/drivers/media/dvb/dvb-usb/af9005-script.h
new file mode 100644
index 00000000000..4d69045426d
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/af9005-script.h
@@ -0,0 +1,203 @@
+/*
+File automatically generated by createinit.py using data
+extracted from AF05BDA.sys (windows driver):
+
+dd if=AF05BDA.sys of=initsequence bs=1 skip=88316 count=1110
+python createinit.py > af9005-script.h
+
+*/
+
+typedef struct {
+        u16 reg;
+        u8 pos;
+        u8 len;
+        u8 val;
+} RegDesc;
+
+static RegDesc script[] = {
+        {0xa180, 0x0, 0x8, 0xa},
+        {0xa181, 0x0, 0x8, 0xd7},
+        {0xa182, 0x0, 0x8, 0xa3},
+        {0xa0a0, 0x0, 0x8, 0x0},
+        {0xa0a1, 0x0, 0x5, 0x0},
+        {0xa0a1, 0x5, 0x1, 0x1},
+        {0xa0c0, 0x0, 0x4, 0x1},
+        {0xa20e, 0x4, 0x4, 0xa},
+        {0xa20f, 0x0, 0x8, 0x40},
+        {0xa210, 0x0, 0x8, 0x8},
+        {0xa32a, 0x0, 0x4, 0xa},
+        {0xa32c, 0x0, 0x8, 0x20},
+        {0xa32b, 0x0, 0x8, 0x15},
+        {0xa1a0, 0x1, 0x1, 0x1},
+        {0xa000, 0x0, 0x1, 0x1},
+        {0xa000, 0x1, 0x1, 0x0},
+        {0xa001, 0x1, 0x1, 0x1},
+        {0xa001, 0x0, 0x1, 0x0},
+        {0xa001, 0x5, 0x1, 0x0},
+        {0xa00e, 0x0, 0x5, 0x10},
+        {0xa00f, 0x0, 0x3, 0x4},
+        {0xa00f, 0x3, 0x3, 0x5},
+        {0xa010, 0x0, 0x3, 0x4},
+        {0xa010, 0x3, 0x3, 0x5},
+        {0xa016, 0x4, 0x4, 0x3},
+        {0xa01f, 0x0, 0x6, 0xa},
+        {0xa020, 0x0, 0x6, 0xa},
+        {0xa2bc, 0x0, 0x1, 0x1},
+        {0xa2bc, 0x5, 0x1, 0x1},
+        {0xa015, 0x0, 0x8, 0x50},
+        {0xa016, 0x0, 0x1, 0x0},
+        {0xa02a, 0x0, 0x8, 0x50},
+        {0xa029, 0x0, 0x8, 0x4b},
+        {0xa614, 0x0, 0x8, 0x46},
+        {0xa002, 0x0, 0x5, 0x19},
+        {0xa003, 0x0, 0x5, 0x1a},
+        {0xa004, 0x0, 0x5, 0x19},
+        {0xa005, 0x0, 0x5, 0x1a},
+        {0xa008, 0x0, 0x8, 0x69},
+        {0xa009, 0x0, 0x2, 0x2},
+        {0xae1b, 0x0, 0x8, 0x69},
+        {0xae1c, 0x0, 0x8, 0x2},
+        {0xae1d, 0x0, 0x8, 0x2a},
+        {0xa022, 0x0, 0x8, 0xaa},
+        {0xa006, 0x0, 0x8, 0xc8},
+        {0xa007, 0x0, 0x2, 0x0},
+        {0xa00c, 0x0, 0x8, 0xba},
+        {0xa00d, 0x0, 0x2, 0x2},
+        {0xa608, 0x0, 0x8, 0xba},
+        {0xa60e, 0x0, 0x2, 0x2},
+        {0xa609, 0x0, 0x8, 0x80},
+        {0xa60e, 0x2, 0x2, 0x3},
+        {0xa00a, 0x0, 0x8, 0xb6},
+        {0xa00b, 0x0, 0x2, 0x0},
+        {0xa011, 0x0, 0x8, 0xb9},
+        {0xa012, 0x0, 0x2, 0x0},
+        {0xa013, 0x0, 0x8, 0xbd},
+        {0xa014, 0x0, 0x2, 0x2},
+        {0xa366, 0x0, 0x1, 0x1},
+        {0xa2bc, 0x3, 0x1, 0x0},
+        {0xa2bd, 0x0, 0x8, 0xa},
+        {0xa2be, 0x0, 0x8, 0x14},
+        {0xa2bf, 0x0, 0x8, 0x8},
+        {0xa60a, 0x0, 0x8, 0xbd},
+        {0xa60e, 0x4, 0x2, 0x2},
+        {0xa60b, 0x0, 0x8, 0x86},
+        {0xa60e, 0x6, 0x2, 0x3},
+        {0xa001, 0x2, 0x2, 0x1},
+        {0xa1c7, 0x0, 0x8, 0xf5},
+        {0xa03d, 0x0, 0x8, 0xb1},
+        {0xa616, 0x0, 0x8, 0xff},
+        {0xa617, 0x0, 0x8, 0xad},
+        {0xa618, 0x0, 0x8, 0xad},
+        {0xa61e, 0x3, 0x1, 0x1},
+        {0xae1a, 0x0, 0x8, 0x0},
+        {0xae19, 0x0, 0x8, 0xc8},
+        {0xae18, 0x0, 0x8, 0x61},
+        {0xa140, 0x0, 0x8, 0x0},
+        {0xa141, 0x0, 0x8, 0xc8},
+        {0xa142, 0x0, 0x7, 0x61},
+        {0xa023, 0x0, 0x8, 0xff},
+        {0xa021, 0x0, 0x8, 0xad},
+        {0xa026, 0x0, 0x1, 0x0},
+        {0xa024, 0x0, 0x8, 0xff},
+        {0xa025, 0x0, 0x8, 0xff},
+        {0xa1c8, 0x0, 0x8, 0xf},
+        {0xa2bc, 0x1, 0x1, 0x0},
+        {0xa60c, 0x0, 0x4, 0x5},
+        {0xa60c, 0x4, 0x4, 0x6},
+        {0xa60d, 0x0, 0x8, 0xa},
+        {0xa371, 0x0, 0x1, 0x1},
+        {0xa366, 0x1, 0x3, 0x7},
+        {0xa338, 0x0, 0x8, 0x10},
+        {0xa339, 0x0, 0x6, 0x7},
+        {0xa33a, 0x0, 0x6, 0x1f},
+        {0xa33b, 0x0, 0x8, 0xf6},
+        {0xa33c, 0x3, 0x5, 0x4},
+        {0xa33d, 0x4, 0x4, 0x0},
+        {0xa33d, 0x1, 0x1, 0x1},
+        {0xa33d, 0x2, 0x1, 0x1},
+        {0xa33d, 0x3, 0x1, 0x1},
+        {0xa16d, 0x0, 0x4, 0xf},
+        {0xa161, 0x0, 0x5, 0x5},
+        {0xa162, 0x0, 0x4, 0x5},
+        {0xa165, 0x0, 0x8, 0xff},
+        {0xa166, 0x0, 0x8, 0x9c},
+        {0xa2c3, 0x0, 0x4, 0x5},
+        {0xa61a, 0x0, 0x6, 0xf},
+        {0xb200, 0x0, 0x8, 0xa1},
+        {0xb201, 0x0, 0x8, 0x7},
+        {0xa093, 0x0, 0x1, 0x0},
+        {0xa093, 0x1, 0x5, 0xf},
+        {0xa094, 0x0, 0x8, 0xff},
+        {0xa095, 0x0, 0x8, 0xf},
+        {0xa080, 0x2, 0x5, 0x3},
+        {0xa081, 0x0, 0x4, 0x0},
+        {0xa081, 0x4, 0x4, 0x9},
+        {0xa082, 0x0, 0x5, 0x1f},
+        {0xa08d, 0x0, 0x8, 0x1},
+        {0xa083, 0x0, 0x8, 0x32},
+        {0xa084, 0x0, 0x1, 0x0},
+        {0xa08e, 0x0, 0x8, 0x3},
+        {0xa085, 0x0, 0x8, 0x32},
+        {0xa086, 0x0, 0x3, 0x0},
+        {0xa087, 0x0, 0x8, 0x6e},
+        {0xa088, 0x0, 0x5, 0x15},
+        {0xa089, 0x0, 0x8, 0x0},
+        {0xa08a, 0x0, 0x5, 0x19},
+        {0xa08b, 0x0, 0x8, 0x92},
+        {0xa08c, 0x0, 0x5, 0x1c},
+        {0xa120, 0x0, 0x8, 0x0},
+        {0xa121, 0x0, 0x5, 0x10},
+        {0xa122, 0x0, 0x8, 0x0},
+        {0xa123, 0x0, 0x7, 0x40},
+        {0xa123, 0x7, 0x1, 0x0},
+        {0xa124, 0x0, 0x8, 0x13},
+        {0xa125, 0x0, 0x7, 0x10},
+        {0xa1c0, 0x0, 0x8, 0x0},
+        {0xa1c1, 0x0, 0x5, 0x4},
+        {0xa1c2, 0x0, 0x8, 0x0},
+        {0xa1c3, 0x0, 0x5, 0x10},
+        {0xa1c3, 0x5, 0x3, 0x0},
+        {0xa1c4, 0x0, 0x6, 0x0},
+        {0xa1c5, 0x0, 0x7, 0x10},
+        {0xa100, 0x0, 0x8, 0x0},
+        {0xa101, 0x0, 0x5, 0x10},
+        {0xa102, 0x0, 0x8, 0x0},
+        {0xa103, 0x0, 0x7, 0x40},
+        {0xa103, 0x7, 0x1, 0x0},
+        {0xa104, 0x0, 0x8, 0x18},
+        {0xa105, 0x0, 0x7, 0xa},
+        {0xa106, 0x0, 0x8, 0x20},
+        {0xa107, 0x0, 0x8, 0x40},
+        {0xa108, 0x0, 0x4, 0x0},
+        {0xa38c, 0x0, 0x8, 0xfc},
+        {0xa38d, 0x0, 0x8, 0x0},
+        {0xa38e, 0x0, 0x8, 0x7e},
+        {0xa38f, 0x0, 0x8, 0x0},
+        {0xa390, 0x0, 0x8, 0x2f},
+        {0xa60f, 0x5, 0x1, 0x1},
+        {0xa170, 0x0, 0x8, 0xdc},
+        {0xa171, 0x0, 0x2, 0x0},
+        {0xa2ae, 0x0, 0x1, 0x1},
+        {0xa2ae, 0x1, 0x1, 0x1},
+        {0xa392, 0x0, 0x1, 0x1},
+        {0xa391, 0x2, 0x1, 0x0},
+        {0xabc1, 0x0, 0x8, 0xff},
+        {0xabc2, 0x0, 0x8, 0x0},
+        {0xabc8, 0x0, 0x8, 0x8},
+        {0xabca, 0x0, 0x8, 0x10},
+        {0xabcb, 0x0, 0x1, 0x0},
+        {0xabc3, 0x5, 0x3, 0x7},
+        {0xabc0, 0x6, 0x1, 0x0},
+        {0xabc0, 0x4, 0x2, 0x0},
+        {0xa344, 0x4, 0x4, 0x1},
+        {0xabc0, 0x7, 0x1, 0x1},
+        {0xabc0, 0x2, 0x1, 0x1},
+        {0xa345, 0x0, 0x8, 0x66},
+        {0xa346, 0x0, 0x8, 0x66},
+        {0xa347, 0x0, 0x4, 0x0},
+        {0xa343, 0x0, 0x4, 0xa},
+        {0xa347, 0x4, 0x4, 0x2},
+        {0xa348, 0x0, 0x4, 0xc},
+        {0xa348, 0x4, 0x4, 0x7},
+        {0xa349, 0x0, 0x6, 0x2},
+};
diff --git a/drivers/media/dvb/dvb-usb/af9005.c b/drivers/media/dvb/dvb-usb/af9005.c
new file mode 100644
index 00000000000..51f6439dcfd
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/af9005.c
@@ -0,0 +1,1105 @@
+/* DVB USB compliant Linux driver for the Afatech 9005
+ * USB1.1 DVB-T receiver.
+ *
+ * Copyright (C) 2007 Luca Olivetti (luca@ventoso.org)
+ *
+ * Thanks to Afatech who kindly provided information.
+ *
+ * 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.
+ *
+ * see Documentation/dvb/REDME.dvb-usb for more information
+ */
+#include "af9005.h"
+
+/* debug */
+int dvb_usb_af9005_debug;
+module_param_named(debug, dvb_usb_af9005_debug, int, 0644);
+MODULE_PARM_DESC(debug,
+                 "set debugging level (1=info,xfer=2,rc=4,reg=8,i2c=16,fw=32 (or-able))."
+                 DVB_USB_DEBUG_STATUS);
+/* enable obnoxious led */
+int dvb_usb_af9005_led = 1;
+module_param_named(led, dvb_usb_af9005_led, bool, 0644);
+MODULE_PARM_DESC(led, "enable led (default: 1).");
+
+/* eeprom dump */
+static int dvb_usb_af9005_dump_eeprom;
+module_param_named(dump_eeprom, dvb_usb_af9005_dump_eeprom, int, 0);
+MODULE_PARM_DESC(dump_eeprom, "dump contents of the eeprom.");
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+/* remote control decoder */
+static int (*rc_decode) (struct dvb_usb_device *d, u8 *data, int len,
+                u32 *event, int *state);
+static void *rc_keys;
+static int *rc_keys_size;
+
+u8 regmask[8] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
+
+struct af9005_device_state {
+        u8 sequence;
+        int led_state;
+};
+
+static int af9005_generic_read_write(struct dvb_usb_device *d, u16 reg,
+                              int readwrite, int type, u8 * values, int len)
+{
+        struct af9005_device_state *st = d->priv;
+        u8 obuf[16] = { 0 };
+        u8 ibuf[17] = { 0 };
+        u8 command;
+        int i;
+        int ret;
+
+        if (len < 1) {
+                err("generic read/write, less than 1 byte. Makes no sense.");
+                return -EINVAL;
+        }
+        if (len > 8) {
+                err("generic read/write, more than 8 bytes. Not supported.");
+                return -EINVAL;
+        }
+
+        obuf[0] = 14;           /* rest of buffer length low */
+        obuf[1] = 0;            /* rest of buffer length high */
+
+        obuf[2] = AF9005_REGISTER_RW;   /* register operation */
+        obuf[3] = 12;           /* rest of buffer length */
+
+        obuf[4] = st->sequence++;       /* sequence number */
+
+        obuf[5] = (u8) (reg >> 8);      /* register address */
+        obuf[6] = (u8) (reg & 0xff);
+
+        if (type == AF9005_OFDM_REG) {
+                command = AF9005_CMD_OFDM_REG;
+        } else {
+                command = AF9005_CMD_TUNER;
+        }
+
+        if (len > 1)
+                command |=
+                    AF9005_CMD_BURST | AF9005_CMD_AUTOINC | (len - 1) << 3;
+        command |= readwrite;
+        if (readwrite == AF9005_CMD_WRITE)
+                for (i = 0; i < len; i++)
+                        obuf[8 + i] = values[i];
+        else if (type == AF9005_TUNER_REG)
+                /* read command for tuner, the first byte contains the i2c address */
+                obuf[8] = values[0];
+        obuf[7] = command;
+
+        ret = dvb_usb_generic_rw(d, obuf, 16, ibuf, 17, 0);
+        if (ret)
+                return ret;
+
+        /* sanity check */
+        if (ibuf[2] != AF9005_REGISTER_RW_ACK) {
+                err("generic read/write, wrong reply code.");
+                return -EIO;
+        }
+        if (ibuf[3] != 0x0d) {
+                err("generic read/write, wrong length in reply.");
+                return -EIO;
+        }
+        if (ibuf[4] != obuf[4]) {
+                err("generic read/write, wrong sequence in reply.");
+                return -EIO;
+        }
+        /*
+           Windows driver doesn't check these fields, in fact sometimes
+           the register in the reply is different that what has been sent
+
+           if (ibuf[5] != obuf[5] || ibuf[6] != obuf[6]) {
+           err("generic read/write, wrong register in reply.");
+           return -EIO;
+           }
+           if (ibuf[7] != command) {
+           err("generic read/write wrong command in reply.");
+           return -EIO;
+           }
+         */
+        if (ibuf[16] != 0x01) {
+                err("generic read/write wrong status code in reply.");
+                return -EIO;
+        }
+        if (readwrite == AF9005_CMD_READ)
+                for (i = 0; i < len; i++)
+                        values[i] = ibuf[8 + i];
+
+        return 0;
+
+}
+
+int af9005_read_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 * value)
+{
+        int ret;
+        deb_reg("read register %x ", reg);
+        ret = af9005_generic_read_write(d, reg,
+                                        AF9005_CMD_READ, AF9005_OFDM_REG,
+                                        value, 1);
+        if (ret)
+                deb_reg("failed\n");
+        else
+                deb_reg("value %x\n", *value);
+        return ret;
+}
+
+int af9005_read_ofdm_registers(struct dvb_usb_device *d, u16 reg,
+                               u8 * values, int len)
+{
+        int ret;
+        deb_reg("read %d registers %x ", len, reg);
+        ret = af9005_generic_read_write(d, reg,
+                                        AF9005_CMD_READ, AF9005_OFDM_REG,
+                                        values, len);
+        if (ret)
+                deb_reg("failed\n");
+        else
+                debug_dump(values, len, deb_reg);
+        return ret;
+}
+
+int af9005_write_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 value)
+{
+        int ret;
+        u8 temp = value;
+        deb_reg("write register %x value %x ", reg, value);
+        ret = af9005_generic_read_write(d, reg,
+                                        AF9005_CMD_WRITE, AF9005_OFDM_REG,
+                                        &temp, 1);
+        if (ret)
+                deb_reg("failed\n");
+        else
+                deb_reg("ok\n");
+        return ret;
+}
+
+int af9005_write_ofdm_registers(struct dvb_usb_device *d, u16 reg,
+                                u8 * values, int len)
+{
+        int ret;
+        deb_reg("write %d registers %x values ", len, reg);
+        debug_dump(values, len, deb_reg);
+
+        ret = af9005_generic_read_write(d, reg,
+                                        AF9005_CMD_WRITE, AF9005_OFDM_REG,
+                                        values, len);
+        if (ret)
+                deb_reg("failed\n");
+        else
+                deb_reg("ok\n");
+        return ret;
+}
+
+int af9005_read_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos,
+                              u8 len, u8 * value)
+{
+        u8 temp;
+        int ret;
+        deb_reg("read bits %x %x %x", reg, pos, len);
+        ret = af9005_read_ofdm_register(d, reg, &temp);
+        if (ret) {
+                deb_reg(" failed\n");
+                return ret;
+        }
+        *value = (temp >> pos) & regmask[len - 1];
+        deb_reg(" value %x\n", *value);
+        return 0;
+
+}
+
+int af9005_write_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos,
+                               u8 len, u8 value)
+{
+        u8 temp, mask;
+        int ret;
+        deb_reg("write bits %x %x %x value %x\n", reg, pos, len, value);
+        if (pos == 0 && len == 8)
+                return af9005_write_ofdm_register(d, reg, value);
+        ret = af9005_read_ofdm_register(d, reg, &temp);
+        if (ret)
+                return ret;
+        mask = regmask[len - 1] << pos;
+        temp = (temp & ~mask) | ((value << pos) & mask);
+        return af9005_write_ofdm_register(d, reg, temp);
+
+}
+
+static int af9005_usb_read_tuner_registers(struct dvb_usb_device *d,
+                                           u16 reg, u8 * values, int len)
+{
+        return af9005_generic_read_write(d, reg,
+                                         AF9005_CMD_READ, AF9005_TUNER_REG,
+                                         values, len);
+}
+
+static int af9005_usb_write_tuner_registers(struct dvb_usb_device *d,
+                                            u16 reg, u8 * values, int len)
+{
+        return af9005_generic_read_write(d, reg,
+                                         AF9005_CMD_WRITE,
+                                         AF9005_TUNER_REG, values, len);
+}
+
+int af9005_write_tuner_registers(struct dvb_usb_device *d, u16 reg,
+                                 u8 * values, int len)
+{
+        /* don't let the name of this function mislead you: it's just used
+           as an interface from the firmware to the i2c bus. The actual
+           i2c addresses are contained in the data */
+        int ret, i, done = 0, fail = 0;
+        u8 temp;
+        ret = af9005_usb_write_tuner_registers(d, reg, values, len);
+        if (ret)
+                return ret;
+        if (reg != 0xffff) {
+                /* check if write done (0xa40d bit 1) or fail (0xa40d bit 2) */
+                for (i = 0; i < 200; i++) {
+                        ret =
+                            af9005_read_ofdm_register(d,
+                                                      xd_I2C_i2c_m_status_wdat_done,
+                                                      &temp);
+                        if (ret)
+                                return ret;
+                        done = temp & (regmask[i2c_m_status_wdat_done_len - 1]
+                                       << i2c_m_status_wdat_done_pos);
+                        if (done)
+                                break;
+                        fail = temp & (regmask[i2c_m_status_wdat_fail_len - 1]
+                                       << i2c_m_status_wdat_fail_pos);
+                        if (fail)
+                                break;
+                        msleep(50);
+                }
+                if (i == 200)
+                        return -ETIMEDOUT;
+                if (fail) {
+                        /* clear write fail bit */
+                        af9005_write_register_bits(d,
+                                                   xd_I2C_i2c_m_status_wdat_fail,
+                                                   i2c_m_status_wdat_fail_pos,
+                                                   i2c_m_status_wdat_fail_len,
+                                                   1);
+                        return -EIO;
+                }
+                /* clear write done bit */
+                ret =
+                    af9005_write_register_bits(d,
+                                               xd_I2C_i2c_m_status_wdat_fail,
+                                               i2c_m_status_wdat_done_pos,
+                                               i2c_m_status_wdat_done_len, 1);
+                if (ret)
+                        return ret;
+        }
+        return 0;
+}
+
+int af9005_read_tuner_registers(struct dvb_usb_device *d, u16 reg, u8 addr,
+                                u8 * values, int len)
+{
+        /* don't let the name of this function mislead you: it's just used
+           as an interface from the firmware to the i2c bus. The actual
+           i2c addresses are contained in the data */
+        int ret, i;
+        u8 temp, buf[2];
+
+        buf[0] = addr;          /* tuner i2c address */
+        buf[1] = values[0];     /* tuner register */
+
+        values[0] = addr + 0x01;        /* i2c read address */
+
+        if (reg == APO_REG_I2C_RW_SILICON_TUNER) {
+                /* write tuner i2c address to tuner, 0c00c0 undocumented, found by sniffing */
+                ret = af9005_write_tuner_registers(d, 0x00c0, buf, 2);
+                if (ret)
+                        return ret;
+        }
+
+        /* send read command to ofsm */
+        ret = af9005_usb_read_tuner_registers(d, reg, values, 1);
+        if (ret)
+                return ret;
+
+        /* check if read done */
+        for (i = 0; i < 200; i++) {
+                ret = af9005_read_ofdm_register(d, 0xa408, &temp);
+                if (ret)
+                        return ret;
+                if (temp & 0x01)
+                        break;
+                msleep(50);
+        }
+        if (i == 200)
+                return -ETIMEDOUT;
+
+        /* clear read done bit (by writing 1) */
+        ret = af9005_write_ofdm_register(d, xd_I2C_i2c_m_data8, 1);
+        if (ret)
+                return ret;
+
+        /* get read data (available from 0xa400) */
+        for (i = 0; i < len; i++) {
+                ret = af9005_read_ofdm_register(d, 0xa400 + i, &temp);
+                if (ret)
+                        return ret;
+                values[i] = temp;
+        }
+        return 0;
+}
+
+static int af9005_i2c_write(struct dvb_usb_device *d, u8 i2caddr, u8 reg,
+                            u8 * data, int len)
+{
+        int ret, i;
+        u8 buf[3];
+        deb_i2c("i2c_write i2caddr %x, reg %x, len %d data ", i2caddr,
+                reg, len);
+        debug_dump(data, len, deb_i2c);
+
+        for (i = 0; i < len; i++) {
+                buf[0] = i2caddr;
+                buf[1] = reg + (u8) i;
+                buf[2] = data[i];
+                ret =
+                    af9005_write_tuner_registers(d,
+                                                 APO_REG_I2C_RW_SILICON_TUNER,
+                                                 buf, 3);
+                if (ret) {
+                        deb_i2c("i2c_write failed\n");
+                        return ret;
+                }
+        }
+        deb_i2c("i2c_write ok\n");
+        return 0;
+}
+
+static int af9005_i2c_read(struct dvb_usb_device *d, u8 i2caddr, u8 reg,
+                           u8 * data, int len)
+{
+        int ret, i;
+        u8 temp;
+        deb_i2c("i2c_read i2caddr %x, reg %x, len %d\n ", i2caddr, reg, len);
+        for (i = 0; i < len; i++) {
+                temp = reg + i;
+                ret =
+                    af9005_read_tuner_registers(d,
+                                                APO_REG_I2C_RW_SILICON_TUNER,
+                                                i2caddr, &temp, 1);
+                if (ret) {
+                        deb_i2c("i2c_read failed\n");
+                        return ret;
+                }
+                data[i] = temp;
+        }
+        deb_i2c("i2c data read: ");
+        debug_dump(data, len, deb_i2c);
+        return 0;
+}
+
+static int af9005_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                           int num)
+{
+        /* only implements what the mt2060 module does, don't know how
+           to make it really generic */
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int ret;
+        u8 reg, addr;
+        u8 *value;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        if (num > 2)
+                warn("more than 2 i2c messages at a time is not handled yet. TODO.");
+
+        if (num == 2) {
+                /* reads a single register */
+                reg = *msg[0].buf;
+                addr = msg[0].addr;
+                value = msg[1].buf;
+                ret = af9005_i2c_read(d, addr, reg, value, 1);
+                if (ret == 0)
+                        ret = 2;
+        } else {
+                /* write one or more registers */
+                reg = msg[0].buf[0];
+                addr = msg[0].addr;
+                value = &msg[0].buf[1];
+                ret = af9005_i2c_write(d, addr, reg, value, msg[0].len - 1);
+                if (ret == 0)
+                        ret = 1;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return ret;
+}
+
+static u32 af9005_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm af9005_i2c_algo = {
+        .master_xfer = af9005_i2c_xfer,
+        .functionality = af9005_i2c_func,
+};
+
+int af9005_send_command(struct dvb_usb_device *d, u8 command, u8 * wbuf,
+                        int wlen, u8 * rbuf, int rlen)
+{
+        struct af9005_device_state *st = d->priv;
+
+        int ret, i, packet_len;
+        u8 buf[64];
+        u8 ibuf[64];
+
+        if (wlen < 0) {
+                err("send command, wlen less than 0 bytes. Makes no sense.");
+                return -EINVAL;
+        }
+        if (wlen > 54) {
+                err("send command, wlen more than 54 bytes. Not supported.");
+                return -EINVAL;
+        }
+        if (rlen > 54) {
+                err("send command, rlen more than 54 bytes. Not supported.");
+                return -EINVAL;
+        }
+        packet_len = wlen + 5;
+        buf[0] = (u8) (packet_len & 0xff);
+        buf[1] = (u8) ((packet_len & 0xff00) >> 8);
+
+        buf[2] = 0x26;          /* packet type */
+        buf[3] = wlen + 3;
+        buf[4] = st->sequence++;
+        buf[5] = command;
+        buf[6] = wlen;
+        for (i = 0; i < wlen; i++)
+                buf[7 + i] = wbuf[i];
+        ret = dvb_usb_generic_rw(d, buf, wlen + 7, ibuf, rlen + 7, 0);
+        if (ret)
+                return ret;
+        if (ibuf[2] != 0x27) {
+                err("send command, wrong reply code.");
+                return -EIO;
+        }
+        if (ibuf[4] != buf[4]) {
+                err("send command, wrong sequence in reply.");
+                return -EIO;
+        }
+        if (ibuf[5] != 0x01) {
+                err("send command, wrong status code in reply.");
+                return -EIO;
+        }
+        if (ibuf[6] != rlen) {
+                err("send command, invalid data length in reply.");
+                return -EIO;
+        }
+        for (i = 0; i < rlen; i++)
+                rbuf[i] = ibuf[i + 7];
+        return 0;
+}
+
+int af9005_read_eeprom(struct dvb_usb_device *d, u8 address, u8 * values,
+                       int len)
+{
+        struct af9005_device_state *st = d->priv;
+        u8 obuf[16], ibuf[14];
+        int ret, i;
+
+        memset(obuf, 0, sizeof(obuf));
+        memset(ibuf, 0, sizeof(ibuf));
+
+        obuf[0] = 14;           /* length of rest of packet low */
+        obuf[1] = 0;            /* length of rest of packer high */
+
+        obuf[2] = 0x2a;         /* read/write eeprom */
+
+        obuf[3] = 12;           /* size */
+
+        obuf[4] = st->sequence++;
+
+        obuf[5] = 0;            /* read */
+
+        obuf[6] = len;
+        obuf[7] = address;
+        ret = dvb_usb_generic_rw(d, obuf, 16, ibuf, 14, 0);
+        if (ret)
+                return ret;
+        if (ibuf[2] != 0x2b) {
+                err("Read eeprom, invalid reply code");
+                return -EIO;
+        }
+        if (ibuf[3] != 10) {
+                err("Read eeprom, invalid reply length");
+                return -EIO;
+        }
+        if (ibuf[4] != obuf[4]) {
+                err("Read eeprom, wrong sequence in reply ");
+                return -EIO;
+        }
+        if (ibuf[5] != 1) {
+                err("Read eeprom, wrong status in reply ");
+                return -EIO;
+        }
+        for (i = 0; i < len; i++) {
+                values[i] = ibuf[6 + i];
+        }
+        return 0;
+}
+
+static int af9005_boot_packet(struct usb_device *udev, int type, u8 * reply)
+{
+        u8 buf[FW_BULKOUT_SIZE + 2];
+        u16 checksum;
+        int act_len, i, ret;
+        memset(buf, 0, sizeof(buf));
+        buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
+        buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
+        switch (type) {
+        case FW_CONFIG:
+                buf[2] = 0x11;
+                buf[3] = 0x04;
+                buf[4] = 0x00;  /* sequence number, original driver doesn't increment it here */
+                buf[5] = 0x03;
+                checksum = buf[4] + buf[5];
+                buf[6] = (u8) ((checksum >> 8) & 0xff);
+                buf[7] = (u8) (checksum & 0xff);
+                break;
+        case FW_CONFIRM:
+                buf[2] = 0x11;
+                buf[3] = 0x04;
+                buf[4] = 0x00;  /* sequence number, original driver doesn't increment it here */
+                buf[5] = 0x01;
+                checksum = buf[4] + buf[5];
+                buf[6] = (u8) ((checksum >> 8) & 0xff);
+                buf[7] = (u8) (checksum & 0xff);
+                break;
+        case FW_BOOT:
+                buf[2] = 0x10;
+                buf[3] = 0x08;
+                buf[4] = 0x00;  /* sequence number, original driver doesn't increment it here */
+                buf[5] = 0x97;
+                buf[6] = 0xaa;
+                buf[7] = 0x55;
+                buf[8] = 0xa5;
+                buf[9] = 0x5a;
+                checksum = 0;
+                for (i = 4; i <= 9; i++)
+                        checksum += buf[i];
+                buf[10] = (u8) ((checksum >> 8) & 0xff);
+                buf[11] = (u8) (checksum & 0xff);
+                break;
+        default:
+                err("boot packet invalid boot packet type");
+                return -EINVAL;
+        }
+        deb_fw(">>> ");
+        debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
+
+        ret = usb_bulk_msg(udev,
+                           usb_sndbulkpipe(udev, 0x02),
+                           buf, FW_BULKOUT_SIZE + 2, &act_len, 2000);
+        if (ret)
+                err("boot packet bulk message failed: %d (%d/%d)", ret,
+                    FW_BULKOUT_SIZE + 2, act_len);
+        else
+                ret = act_len != FW_BULKOUT_SIZE + 2 ? -1 : 0;
+        if (ret)
+                return ret;
+        memset(buf, 0, 9);
+        ret = usb_bulk_msg(udev,
+                           usb_rcvbulkpipe(udev, 0x01), buf, 9, &act_len, 2000);
+        if (ret) {
+                err("boot packet recv bulk message failed: %d", ret);
+                return ret;
+        }
+        deb_fw("<<< ");
+        debug_dump(buf, act_len, deb_fw);
+        checksum = 0;
+        switch (type) {
+        case FW_CONFIG:
+                if (buf[2] != 0x11) {
+                        err("boot bad config header.");
+                        return -EIO;
+                }
+                if (buf[3] != 0x05) {
+                        err("boot bad config size.");
+                        return -EIO;
+                }
+                if (buf[4] != 0x00) {
+                        err("boot bad config sequence.");
+                        return -EIO;
+                }
+                if (buf[5] != 0x04) {
+                        err("boot bad config subtype.");
+                        return -EIO;
+                }
+                for (i = 4; i <= 6; i++)
+                        checksum += buf[i];
+                if (buf[7] * 256 + buf[8] != checksum) {
+                        err("boot bad config checksum.");
+                        return -EIO;
+                }
+                *reply = buf[6];
+                break;
+        case FW_CONFIRM:
+                if (buf[2] != 0x11) {
+                        err("boot bad confirm header.");
+                        return -EIO;
+                }
+                if (buf[3] != 0x05) {
+                        err("boot bad confirm size.");
+                        return -EIO;
+                }
+                if (buf[4] != 0x00) {
+                        err("boot bad confirm sequence.");
+                        return -EIO;
+                }
+                if (buf[5] != 0x02) {
+                        err("boot bad confirm subtype.");
+                        return -EIO;
+                }
+                for (i = 4; i <= 6; i++)
+                        checksum += buf[i];
+                if (buf[7] * 256 + buf[8] != checksum) {
+                        err("boot bad confirm checksum.");
+                        return -EIO;
+                }
+                *reply = buf[6];
+                break;
+        case FW_BOOT:
+                if (buf[2] != 0x10) {
+                        err("boot bad boot header.");
+                        return -EIO;
+                }
+                if (buf[3] != 0x05) {
+                        err("boot bad boot size.");
+                        return -EIO;
+                }
+                if (buf[4] != 0x00) {
+                        err("boot bad boot sequence.");
+                        return -EIO;
+                }
+                if (buf[5] != 0x01) {
+                        err("boot bad boot pattern 01.");
+                        return -EIO;
+                }
+                if (buf[6] != 0x10) {
+                        err("boot bad boot pattern 10.");
+                        return -EIO;
+                }
+                for (i = 4; i <= 6; i++)
+                        checksum += buf[i];
+                if (buf[7] * 256 + buf[8] != checksum) {
+                        err("boot bad boot checksum.");
+                        return -EIO;
+                }
+                break;
+
+        }
+
+        return 0;
+}
+
+static int af9005_download_firmware(struct usb_device *udev, const struct firmware *fw)
+{
+        int i, packets, ret, act_len;
+
+        u8 buf[FW_BULKOUT_SIZE + 2];
+        u8 reply;
+
+        ret = af9005_boot_packet(udev, FW_CONFIG, &reply);
+        if (ret)
+                return ret;
+        if (reply != 0x01) {
+                err("before downloading firmware, FW_CONFIG expected 0x01, received 0x%x", reply);
+                return -EIO;
+        }
+        packets = fw->size / FW_BULKOUT_SIZE;
+        buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
+        buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
+        for (i = 0; i < packets; i++) {
+                memcpy(&buf[2], fw->data + i * FW_BULKOUT_SIZE,
+                       FW_BULKOUT_SIZE);
+                deb_fw(">>> ");
+                debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
+                ret = usb_bulk_msg(udev,
+                                   usb_sndbulkpipe(udev, 0x02),
+                                   buf, FW_BULKOUT_SIZE + 2, &act_len, 1000);
+                if (ret) {
+                        err("firmware download failed at packet %d with code %d", i, ret);
+                        return ret;
+                }
+        }
+        ret = af9005_boot_packet(udev, FW_CONFIRM, &reply);
+        if (ret)
+                return ret;
+        if (reply != (u8) (packets & 0xff)) {
+                err("after downloading firmware, FW_CONFIRM expected 0x%x, received 0x%x", packets & 0xff, reply);
+                return -EIO;
+        }
+        ret = af9005_boot_packet(udev, FW_BOOT, &reply);
+        if (ret)
+                return ret;
+        ret = af9005_boot_packet(udev, FW_CONFIG, &reply);
+        if (ret)
+                return ret;
+        if (reply != 0x02) {
+                err("after downloading firmware, FW_CONFIG expected 0x02, received 0x%x", reply);
+                return -EIO;
+        }
+
+        return 0;
+
+}
+
+int af9005_led_control(struct dvb_usb_device *d, int onoff)
+{
+        struct af9005_device_state *st = d->priv;
+        int temp, ret;
+
+        if (onoff && dvb_usb_af9005_led)
+                temp = 1;
+        else
+                temp = 0;
+        if (st->led_state != temp) {
+                ret =
+                    af9005_write_register_bits(d, xd_p_reg_top_locken1,
+                                               reg_top_locken1_pos,
+                                               reg_top_locken1_len, temp);
+                if (ret)
+                        return ret;
+                ret =
+                    af9005_write_register_bits(d, xd_p_reg_top_lock1,
+                                               reg_top_lock1_pos,
+                                               reg_top_lock1_len, temp);
+                if (ret)
+                        return ret;
+                st->led_state = temp;
+        }
+        return 0;
+}
+
+static int af9005_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        u8 buf[8];
+        int i;
+
+        /* without these calls the first commands after downloading
+           the firmware fail. I put these calls here to simulate
+           what it is done in dvb-usb-init.c.
+         */
+        struct usb_device *udev = adap->dev->udev;
+        usb_clear_halt(udev, usb_sndbulkpipe(udev, 2));
+        usb_clear_halt(udev, usb_rcvbulkpipe(udev, 1));
+        if (dvb_usb_af9005_dump_eeprom) {
+                printk("EEPROM DUMP\n");
+                for (i = 0; i < 255; i += 8) {
+                        af9005_read_eeprom(adap->dev, i, buf, 8);
+                        printk("ADDR %x ", i);
+                        debug_dump(buf, 8, printk);
+                }
+        }
+        adap->fe = af9005_fe_attach(adap->dev);
+        return 0;
+}
+
+static int af9005_rc_query(struct dvb_usb_device *d, u32 * event, int *state)
+{
+        struct af9005_device_state *st = d->priv;
+        int ret, len;
+
+        u8 obuf[5];
+        u8 ibuf[256];
+
+        *state = REMOTE_NO_KEY_PRESSED;
+        if (rc_decode == NULL) {
+                /* it shouldn't never come here */
+                return 0;
+        }
+        /* deb_info("rc_query\n"); */
+        obuf[0] = 3;            /* rest of packet length low */
+        obuf[1] = 0;            /* rest of packet lentgh high */
+        obuf[2] = 0x40;         /* read remote */
+        obuf[3] = 1;            /* rest of packet length */
+        obuf[4] = st->sequence++;       /* sequence number */
+        ret = dvb_usb_generic_rw(d, obuf, 5, ibuf, 256, 0);
+        if (ret) {
+                err("rc query failed");
+                return ret;
+        }
+        if (ibuf[2] != 0x41) {
+                err("rc query bad header.");
+                return -EIO;
+        }
+        if (ibuf[4] != obuf[4]) {
+                err("rc query bad sequence.");
+                return -EIO;
+        }
+        len = ibuf[5];
+        if (len > 246) {
+                err("rc query invalid length");
+                return -EIO;
+        }
+        if (len > 0) {
+                deb_rc("rc data (%d) ", len);
+                debug_dump((ibuf + 6), len, deb_rc);
+                ret = rc_decode(d, &ibuf[6], len, event, state);
+                if (ret) {
+                        err("rc_decode failed");
+                        return ret;
+                } else {
+                        deb_rc("rc_decode state %x event %x\n", *state, *event);
+                        if (*state == REMOTE_KEY_REPEAT)
+                                *event = d->last_event;
+                }
+        }
+        return 0;
+}
+
+static int af9005_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+
+        return 0;
+}
+
+static int af9005_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
+{
+        int ret;
+        deb_info("pid filter control  onoff %d\n", onoff);
+        if (onoff) {
+                ret =
+                    af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
+                if (ret)
+                        return ret;
+                ret =
+                    af9005_write_register_bits(adap->dev,
+                                               XD_MP2IF_DMX_CTRL, 1, 1, 1);
+                if (ret)
+                        return ret;
+                ret =
+                    af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
+        } else
+                ret =
+                    af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 0);
+        if (ret)
+                return ret;
+        deb_info("pid filter control ok\n");
+        return 0;
+}
+
+static int af9005_pid_filter(struct dvb_usb_adapter *adap, int index,
+                             u16 pid, int onoff)
+{
+        u8 cmd = index & 0x1f;
+        int ret;
+        deb_info("set pid filter, index %d, pid %x, onoff %d\n", index,
+                 pid, onoff);
+        if (onoff) {
+                /* cannot use it as pid_filter_ctrl since it has to be done
+                   before setting the first pid */
+                if (adap->feedcount == 1) {
+                        deb_info("first pid set, enable pid table\n");
+                        ret = af9005_pid_filter_control(adap, onoff);
+                        if (ret)
+                                return ret;
+                }
+                ret =
+                    af9005_write_ofdm_register(adap->dev,
+                                               XD_MP2IF_PID_DATA_L,
+                                               (u8) (pid & 0xff));
+                if (ret)
+                        return ret;
+                ret =
+                    af9005_write_ofdm_register(adap->dev,
+                                               XD_MP2IF_PID_DATA_H,
+                                               (u8) (pid >> 8));
+                if (ret)
+                        return ret;
+                cmd |= 0x20 | 0x40;
+        } else {
+                if (adap->feedcount == 0) {
+                        deb_info("last pid unset, disable pid table\n");
+                        ret = af9005_pid_filter_control(adap, onoff);
+                        if (ret)
+                                return ret;
+                }
+        }
+        ret = af9005_write_ofdm_register(adap->dev, XD_MP2IF_PID_IDX, cmd);
+        if (ret)
+                return ret;
+        deb_info("set pid ok\n");
+        return 0;
+}
+
+static int af9005_identify_state(struct usb_device *udev,
+                                 struct dvb_usb_device_properties *props,
+                                 struct dvb_usb_device_description **desc,
+                                 int *cold)
+{
+        int ret;
+        u8 reply;
+        ret = af9005_boot_packet(udev, FW_CONFIG, &reply);
+        if (ret)
+                return ret;
+        deb_info("result of FW_CONFIG in identify state %d\n", reply);
+        if (reply == 0x01)
+                *cold = 1;
+        else if (reply == 0x02)
+                *cold = 0;
+        else
+                return -EIO;
+        deb_info("Identify state cold = %d\n", *cold);
+        return 0;
+}
+
+static struct dvb_usb_device_properties af9005_properties;
+
+static int af9005_usb_probe(struct usb_interface *intf,
+                            const struct usb_device_id *id)
+{
+        return dvb_usb_device_init(intf, &af9005_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
+}
+
+static struct usb_device_id af9005_usb_table[] = {
+        {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9005)},
+        {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE)},
+        {USB_DEVICE(USB_VID_ANSONIC, USB_PID_ANSONIC_DVBT_USB)},
+        {0},
+};
+
+MODULE_DEVICE_TABLE(usb, af9005_usb_table);
+
+static struct dvb_usb_device_properties af9005_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "af9005.fw",
+        .download_firmware = af9005_download_firmware,
+        .no_reconnect = 1,
+
+        .size_of_priv = sizeof(struct af9005_device_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                    {
+                     .caps =
+                     DVB_USB_ADAP_HAS_PID_FILTER |
+                     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                     .pid_filter_count = 32,
+                     .pid_filter = af9005_pid_filter,
+                     /* .pid_filter_ctrl = af9005_pid_filter_control, */
+                     .frontend_attach = af9005_frontend_attach,
+                     /* .tuner_attach     = af9005_tuner_attach, */
+                     /* parameter for the MPEG2-data transfer */
+                     .stream = {
+                                .type = USB_BULK,
+                                .count = 10,
+                                .endpoint = 0x04,
+                                .u = {
+                                      .bulk = {
+                                               .buffersize = 4096,      /* actual size seen is 3948 */
+                                               }
+                                      }
+                                },
+                     }
+                    },
+        .power_ctrl = af9005_power_ctrl,
+        .identify_state = af9005_identify_state,
+
+        .i2c_algo = &af9005_i2c_algo,
+
+        .rc.legacy = {
+                .rc_interval = 200,
+                .rc_map_table = NULL,
+                .rc_map_size = 0,
+                .rc_query = af9005_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint          = 2,
+        .generic_bulk_ctrl_endpoint_response = 1,
+
+        .num_device_descs = 3,
+        .devices = {
+                    {.name = "Afatech DVB-T USB1.1 stick",
+                     .cold_ids = {&af9005_usb_table[0], NULL},
+                     .warm_ids = {NULL},
+                     },
+                    {.name = "TerraTec Cinergy T USB XE",
+                     .cold_ids = {&af9005_usb_table[1], NULL},
+                     .warm_ids = {NULL},
+                     },
+                    {.name = "Ansonic DVB-T USB1.1 stick",
+                     .cold_ids = {&af9005_usb_table[2], NULL},
+                     .warm_ids = {NULL},
+                     },
+                    {NULL},
+                    }
+};
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver af9005_usb_driver = {
+        .name = "dvb_usb_af9005",
+        .probe = af9005_usb_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table = af9005_usb_table,
+};
+
+/* module stuff */
+static int __init af9005_usb_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&af9005_usb_driver))) {
+                err("usb_register failed. (%d)", result);
+                return result;
+        }
+        rc_decode = symbol_request(af9005_rc_decode);
+        rc_keys = symbol_request(rc_map_af9005_table);
+        rc_keys_size = symbol_request(rc_map_af9005_table_size);
+        if (rc_decode == NULL || rc_keys == NULL || rc_keys_size == NULL) {
+                err("af9005_rc_decode function not found, disabling remote");
+                af9005_properties.rc.legacy.rc_query = NULL;
+        } else {
+                af9005_properties.rc.legacy.rc_map_table = rc_keys;
+                af9005_properties.rc.legacy.rc_map_size = *rc_keys_size;
+        }
+
+        return 0;
+}
+
+static void __exit af9005_usb_module_exit(void)
+{
+        /* release rc decode symbols */
+        if (rc_decode != NULL)
+                symbol_put(af9005_rc_decode);
+        if (rc_keys != NULL)
+                symbol_put(rc_map_af9005_table);
+        if (rc_keys_size != NULL)
+                symbol_put(rc_map_af9005_table_size);
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&af9005_usb_driver);
+}
+
+module_init(af9005_usb_module_init);
+module_exit(af9005_usb_module_exit);
+
+MODULE_AUTHOR("Luca Olivetti <luca@ventoso.org>");
+MODULE_DESCRIPTION("Driver for Afatech 9005 DVB-T USB1.1 stick");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/af9005.h b/drivers/media/dvb/dvb-usb/af9005.h
new file mode 100644
index 00000000000..c71c77bd7f4
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/af9005.h
@@ -0,0 +1,3496 @@
+/* Common header-file of the Linux driver for the Afatech 9005
+ * USB1.1 DVB-T receiver.
+ *
+ * Copyright (C) 2007 Luca Olivetti (luca@ventoso.org)
+ *
+ * Thanks to Afatech who kindly provided information.
+ *
+ * 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.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_AF9005_H_
+#define _DVB_USB_AF9005_H_
+
+#define DVB_USB_LOG_PREFIX "af9005"
+#include "dvb-usb.h"
+
+extern int dvb_usb_af9005_debug;
+#define deb_info(args...) dprintk(dvb_usb_af9005_debug,0x01,args)
+#define deb_xfer(args...) dprintk(dvb_usb_af9005_debug,0x02,args)
+#define deb_rc(args...)   dprintk(dvb_usb_af9005_debug,0x04,args)
+#define deb_reg(args...)  dprintk(dvb_usb_af9005_debug,0x08,args)
+#define deb_i2c(args...)  dprintk(dvb_usb_af9005_debug,0x10,args)
+#define deb_fw(args...)   dprintk(dvb_usb_af9005_debug,0x20,args)
+
+extern int dvb_usb_af9005_led;
+
+/* firmware */
+#define FW_BULKOUT_SIZE 250
+enum {
+        FW_CONFIG,
+        FW_CONFIRM,
+        FW_BOOT
+};
+
+/* af9005 commands */
+#define AF9005_OFDM_REG  0
+#define AF9005_TUNER_REG 1
+
+#define AF9005_REGISTER_RW     0x20
+#define AF9005_REGISTER_RW_ACK 0x21
+
+#define AF9005_CMD_OFDM_REG 0x00
+#define AF9005_CMD_TUNER    0x80
+#define AF9005_CMD_BURST    0x02
+#define AF9005_CMD_AUTOINC  0x04
+#define AF9005_CMD_READ     0x00
+#define AF9005_CMD_WRITE    0x01
+
+/* af9005 registers */
+#define APO_REG_RESET                                   0xAEFF
+
+#define APO_REG_I2C_RW_CAN_TUNER            0xF000
+#define APO_REG_I2C_RW_SILICON_TUNER        0xF001
+#define APO_REG_GPIO_RW_SILICON_TUNER       0xFFFE      /*  also for OFSM */
+#define APO_REG_TRIGGER_OFSM                0xFFFF      /*  also for OFSM */
+
+/***********************************************************************
+ *  Apollo Registers from VLSI                                         *
+ ***********************************************************************/
+#define xd_p_reg_aagc_inverted_agc      0xA000
+#define reg_aagc_inverted_agc_pos 0
+#define reg_aagc_inverted_agc_len 1
+#define reg_aagc_inverted_agc_lsb 0
+#define xd_p_reg_aagc_sign_only 0xA000
+#define reg_aagc_sign_only_pos 1
+#define reg_aagc_sign_only_len 1
+#define reg_aagc_sign_only_lsb 0
+#define xd_p_reg_aagc_slow_adc_en       0xA000
+#define reg_aagc_slow_adc_en_pos 2
+#define reg_aagc_slow_adc_en_len 1
+#define reg_aagc_slow_adc_en_lsb 0
+#define xd_p_reg_aagc_slow_adc_scale    0xA000
+#define reg_aagc_slow_adc_scale_pos 3
+#define reg_aagc_slow_adc_scale_len 5
+#define reg_aagc_slow_adc_scale_lsb 0
+#define xd_p_reg_aagc_check_slow_adc_lock       0xA001
+#define reg_aagc_check_slow_adc_lock_pos 0
+#define reg_aagc_check_slow_adc_lock_len 1
+#define reg_aagc_check_slow_adc_lock_lsb 0
+#define xd_p_reg_aagc_init_control      0xA001
+#define reg_aagc_init_control_pos 1
+#define reg_aagc_init_control_len 1
+#define reg_aagc_init_control_lsb 0
+#define xd_p_reg_aagc_total_gain_sel    0xA001
+#define reg_aagc_total_gain_sel_pos 2
+#define reg_aagc_total_gain_sel_len 2
+#define reg_aagc_total_gain_sel_lsb 0
+#define xd_p_reg_aagc_out_inv   0xA001
+#define reg_aagc_out_inv_pos 5
+#define reg_aagc_out_inv_len 1
+#define reg_aagc_out_inv_lsb 0
+#define xd_p_reg_aagc_int_en    0xA001
+#define reg_aagc_int_en_pos 6
+#define reg_aagc_int_en_len 1
+#define reg_aagc_int_en_lsb 0
+#define xd_p_reg_aagc_lock_change_flag  0xA001
+#define reg_aagc_lock_change_flag_pos 7
+#define reg_aagc_lock_change_flag_len 1
+#define reg_aagc_lock_change_flag_lsb 0
+#define xd_p_reg_aagc_rf_loop_bw_scale_acquire  0xA002
+#define reg_aagc_rf_loop_bw_scale_acquire_pos 0
+#define reg_aagc_rf_loop_bw_scale_acquire_len 5
+#define reg_aagc_rf_loop_bw_scale_acquire_lsb 0
+#define xd_p_reg_aagc_rf_loop_bw_scale_track    0xA003
+#define reg_aagc_rf_loop_bw_scale_track_pos 0
+#define reg_aagc_rf_loop_bw_scale_track_len 5
+#define reg_aagc_rf_loop_bw_scale_track_lsb 0
+#define xd_p_reg_aagc_if_loop_bw_scale_acquire  0xA004
+#define reg_aagc_if_loop_bw_scale_acquire_pos 0
+#define reg_aagc_if_loop_bw_scale_acquire_len 5
+#define reg_aagc_if_loop_bw_scale_acquire_lsb 0
+#define xd_p_reg_aagc_if_loop_bw_scale_track    0xA005
+#define reg_aagc_if_loop_bw_scale_track_pos 0
+#define reg_aagc_if_loop_bw_scale_track_len 5
+#define reg_aagc_if_loop_bw_scale_track_lsb 0
+#define xd_p_reg_aagc_max_rf_agc_7_0    0xA006
+#define reg_aagc_max_rf_agc_7_0_pos 0
+#define reg_aagc_max_rf_agc_7_0_len 8
+#define reg_aagc_max_rf_agc_7_0_lsb 0
+#define xd_p_reg_aagc_max_rf_agc_9_8    0xA007
+#define reg_aagc_max_rf_agc_9_8_pos 0
+#define reg_aagc_max_rf_agc_9_8_len 2
+#define reg_aagc_max_rf_agc_9_8_lsb 8
+#define xd_p_reg_aagc_min_rf_agc_7_0    0xA008
+#define reg_aagc_min_rf_agc_7_0_pos 0
+#define reg_aagc_min_rf_agc_7_0_len 8
+#define reg_aagc_min_rf_agc_7_0_lsb 0
+#define xd_p_reg_aagc_min_rf_agc_9_8    0xA009
+#define reg_aagc_min_rf_agc_9_8_pos 0
+#define reg_aagc_min_rf_agc_9_8_len 2
+#define reg_aagc_min_rf_agc_9_8_lsb 8
+#define xd_p_reg_aagc_max_if_agc_7_0    0xA00A
+#define reg_aagc_max_if_agc_7_0_pos 0
+#define reg_aagc_max_if_agc_7_0_len 8
+#define reg_aagc_max_if_agc_7_0_lsb 0
+#define xd_p_reg_aagc_max_if_agc_9_8    0xA00B
+#define reg_aagc_max_if_agc_9_8_pos 0
+#define reg_aagc_max_if_agc_9_8_len 2
+#define reg_aagc_max_if_agc_9_8_lsb 8
+#define xd_p_reg_aagc_min_if_agc_7_0    0xA00C
+#define reg_aagc_min_if_agc_7_0_pos 0
+#define reg_aagc_min_if_agc_7_0_len 8
+#define reg_aagc_min_if_agc_7_0_lsb 0
+#define xd_p_reg_aagc_min_if_agc_9_8    0xA00D
+#define reg_aagc_min_if_agc_9_8_pos 0
+#define reg_aagc_min_if_agc_9_8_len 2
+#define reg_aagc_min_if_agc_9_8_lsb 8
+#define xd_p_reg_aagc_lock_sample_scale 0xA00E
+#define reg_aagc_lock_sample_scale_pos 0
+#define reg_aagc_lock_sample_scale_len 5
+#define reg_aagc_lock_sample_scale_lsb 0
+#define xd_p_reg_aagc_rf_agc_lock_scale_acquire 0xA00F
+#define reg_aagc_rf_agc_lock_scale_acquire_pos 0
+#define reg_aagc_rf_agc_lock_scale_acquire_len 3
+#define reg_aagc_rf_agc_lock_scale_acquire_lsb 0
+#define xd_p_reg_aagc_rf_agc_lock_scale_track   0xA00F
+#define reg_aagc_rf_agc_lock_scale_track_pos 3
+#define reg_aagc_rf_agc_lock_scale_track_len 3
+#define reg_aagc_rf_agc_lock_scale_track_lsb 0
+#define xd_p_reg_aagc_if_agc_lock_scale_acquire 0xA010
+#define reg_aagc_if_agc_lock_scale_acquire_pos 0
+#define reg_aagc_if_agc_lock_scale_acquire_len 3
+#define reg_aagc_if_agc_lock_scale_acquire_lsb 0
+#define xd_p_reg_aagc_if_agc_lock_scale_track   0xA010
+#define reg_aagc_if_agc_lock_scale_track_pos 3
+#define reg_aagc_if_agc_lock_scale_track_len 3
+#define reg_aagc_if_agc_lock_scale_track_lsb 0
+#define xd_p_reg_aagc_rf_top_numerator_7_0      0xA011
+#define reg_aagc_rf_top_numerator_7_0_pos 0
+#define reg_aagc_rf_top_numerator_7_0_len 8
+#define reg_aagc_rf_top_numerator_7_0_lsb 0
+#define xd_p_reg_aagc_rf_top_numerator_9_8      0xA012
+#define reg_aagc_rf_top_numerator_9_8_pos 0
+#define reg_aagc_rf_top_numerator_9_8_len 2
+#define reg_aagc_rf_top_numerator_9_8_lsb 8
+#define xd_p_reg_aagc_if_top_numerator_7_0      0xA013
+#define reg_aagc_if_top_numerator_7_0_pos 0
+#define reg_aagc_if_top_numerator_7_0_len 8
+#define reg_aagc_if_top_numerator_7_0_lsb 0
+#define xd_p_reg_aagc_if_top_numerator_9_8      0xA014
+#define reg_aagc_if_top_numerator_9_8_pos 0
+#define reg_aagc_if_top_numerator_9_8_len 2
+#define reg_aagc_if_top_numerator_9_8_lsb 8
+#define xd_p_reg_aagc_adc_out_desired_7_0       0xA015
+#define reg_aagc_adc_out_desired_7_0_pos 0
+#define reg_aagc_adc_out_desired_7_0_len 8
+#define reg_aagc_adc_out_desired_7_0_lsb 0
+#define xd_p_reg_aagc_adc_out_desired_8 0xA016
+#define reg_aagc_adc_out_desired_8_pos 0
+#define reg_aagc_adc_out_desired_8_len 1
+#define reg_aagc_adc_out_desired_8_lsb 0
+#define xd_p_reg_aagc_fixed_gain        0xA016
+#define reg_aagc_fixed_gain_pos 3
+#define reg_aagc_fixed_gain_len 1
+#define reg_aagc_fixed_gain_lsb 0
+#define xd_p_reg_aagc_lock_count_th     0xA016
+#define reg_aagc_lock_count_th_pos 4
+#define reg_aagc_lock_count_th_len 4
+#define reg_aagc_lock_count_th_lsb 0
+#define xd_p_reg_aagc_fixed_rf_agc_control_7_0  0xA017
+#define reg_aagc_fixed_rf_agc_control_7_0_pos 0
+#define reg_aagc_fixed_rf_agc_control_7_0_len 8
+#define reg_aagc_fixed_rf_agc_control_7_0_lsb 0
+#define xd_p_reg_aagc_fixed_rf_agc_control_15_8 0xA018
+#define reg_aagc_fixed_rf_agc_control_15_8_pos 0
+#define reg_aagc_fixed_rf_agc_control_15_8_len 8
+#define reg_aagc_fixed_rf_agc_control_15_8_lsb 8
+#define xd_p_reg_aagc_fixed_rf_agc_control_23_16        0xA019
+#define reg_aagc_fixed_rf_agc_control_23_16_pos 0
+#define reg_aagc_fixed_rf_agc_control_23_16_len 8
+#define reg_aagc_fixed_rf_agc_control_23_16_lsb 16
+#define xd_p_reg_aagc_fixed_rf_agc_control_30_24        0xA01A
+#define reg_aagc_fixed_rf_agc_control_30_24_pos 0
+#define reg_aagc_fixed_rf_agc_control_30_24_len 7
+#define reg_aagc_fixed_rf_agc_control_30_24_lsb 24
+#define xd_p_reg_aagc_fixed_if_agc_control_7_0  0xA01B
+#define reg_aagc_fixed_if_agc_control_7_0_pos 0
+#define reg_aagc_fixed_if_agc_control_7_0_len 8
+#define reg_aagc_fixed_if_agc_control_7_0_lsb 0
+#define xd_p_reg_aagc_fixed_if_agc_control_15_8 0xA01C
+#define reg_aagc_fixed_if_agc_control_15_8_pos 0
+#define reg_aagc_fixed_if_agc_control_15_8_len 8
+#define reg_aagc_fixed_if_agc_control_15_8_lsb 8
+#define xd_p_reg_aagc_fixed_if_agc_control_23_16        0xA01D
+#define reg_aagc_fixed_if_agc_control_23_16_pos 0
+#define reg_aagc_fixed_if_agc_control_23_16_len 8
+#define reg_aagc_fixed_if_agc_control_23_16_lsb 16
+#define xd_p_reg_aagc_fixed_if_agc_control_30_24        0xA01E
+#define reg_aagc_fixed_if_agc_control_30_24_pos 0
+#define reg_aagc_fixed_if_agc_control_30_24_len 7
+#define reg_aagc_fixed_if_agc_control_30_24_lsb 24
+#define xd_p_reg_aagc_rf_agc_unlock_numerator   0xA01F
+#define reg_aagc_rf_agc_unlock_numerator_pos 0
+#define reg_aagc_rf_agc_unlock_numerator_len 6
+#define reg_aagc_rf_agc_unlock_numerator_lsb 0
+#define xd_p_reg_aagc_if_agc_unlock_numerator   0xA020
+#define reg_aagc_if_agc_unlock_numerator_pos 0
+#define reg_aagc_if_agc_unlock_numerator_len 6
+#define reg_aagc_if_agc_unlock_numerator_lsb 0
+#define xd_p_reg_unplug_th      0xA021
+#define reg_unplug_th_pos 0
+#define reg_unplug_th_len 8
+#define reg_aagc_rf_x0_lsb 0
+#define xd_p_reg_weak_signal_rfagc_thr 0xA022
+#define reg_weak_signal_rfagc_thr_pos 0
+#define reg_weak_signal_rfagc_thr_len 8
+#define reg_weak_signal_rfagc_thr_lsb 0
+#define xd_p_reg_unplug_rf_gain_th 0xA023
+#define reg_unplug_rf_gain_th_pos 0
+#define reg_unplug_rf_gain_th_len 8
+#define reg_unplug_rf_gain_th_lsb 0
+#define xd_p_reg_unplug_dtop_rf_gain_th 0xA024
+#define reg_unplug_dtop_rf_gain_th_pos 0
+#define reg_unplug_dtop_rf_gain_th_len 8
+#define reg_unplug_dtop_rf_gain_th_lsb 0
+#define xd_p_reg_unplug_dtop_if_gain_th 0xA025
+#define reg_unplug_dtop_if_gain_th_pos 0
+#define reg_unplug_dtop_if_gain_th_len 8
+#define reg_unplug_dtop_if_gain_th_lsb 0
+#define xd_p_reg_top_recover_at_unplug_en 0xA026
+#define reg_top_recover_at_unplug_en_pos 0
+#define reg_top_recover_at_unplug_en_len 1
+#define reg_top_recover_at_unplug_en_lsb 0
+#define xd_p_reg_aagc_rf_x6     0xA027
+#define reg_aagc_rf_x6_pos 0
+#define reg_aagc_rf_x6_len 8
+#define reg_aagc_rf_x6_lsb 0
+#define xd_p_reg_aagc_rf_x7     0xA028
+#define reg_aagc_rf_x7_pos 0
+#define reg_aagc_rf_x7_len 8
+#define reg_aagc_rf_x7_lsb 0
+#define xd_p_reg_aagc_rf_x8     0xA029
+#define reg_aagc_rf_x8_pos 0
+#define reg_aagc_rf_x8_len 8
+#define reg_aagc_rf_x8_lsb 0
+#define xd_p_reg_aagc_rf_x9     0xA02A
+#define reg_aagc_rf_x9_pos 0
+#define reg_aagc_rf_x9_len 8
+#define reg_aagc_rf_x9_lsb 0
+#define xd_p_reg_aagc_rf_x10    0xA02B
+#define reg_aagc_rf_x10_pos 0
+#define reg_aagc_rf_x10_len 8
+#define reg_aagc_rf_x10_lsb 0
+#define xd_p_reg_aagc_rf_x11    0xA02C
+#define reg_aagc_rf_x11_pos 0
+#define reg_aagc_rf_x11_len 8
+#define reg_aagc_rf_x11_lsb 0
+#define xd_p_reg_aagc_rf_x12    0xA02D
+#define reg_aagc_rf_x12_pos 0
+#define reg_aagc_rf_x12_len 8
+#define reg_aagc_rf_x12_lsb 0
+#define xd_p_reg_aagc_rf_x13    0xA02E
+#define reg_aagc_rf_x13_pos 0
+#define reg_aagc_rf_x13_len 8
+#define reg_aagc_rf_x13_lsb 0
+#define xd_p_reg_aagc_if_x0     0xA02F
+#define reg_aagc_if_x0_pos 0
+#define reg_aagc_if_x0_len 8
+#define reg_aagc_if_x0_lsb 0
+#define xd_p_reg_aagc_if_x1     0xA030
+#define reg_aagc_if_x1_pos 0
+#define reg_aagc_if_x1_len 8
+#define reg_aagc_if_x1_lsb 0
+#define xd_p_reg_aagc_if_x2     0xA031
+#define reg_aagc_if_x2_pos 0
+#define reg_aagc_if_x2_len 8
+#define reg_aagc_if_x2_lsb 0
+#define xd_p_reg_aagc_if_x3     0xA032
+#define reg_aagc_if_x3_pos 0
+#define reg_aagc_if_x3_len 8
+#define reg_aagc_if_x3_lsb 0
+#define xd_p_reg_aagc_if_x4     0xA033
+#define reg_aagc_if_x4_pos 0
+#define reg_aagc_if_x4_len 8
+#define reg_aagc_if_x4_lsb 0
+#define xd_p_reg_aagc_if_x5     0xA034
+#define reg_aagc_if_x5_pos 0
+#define reg_aagc_if_x5_len 8
+#define reg_aagc_if_x5_lsb 0
+#define xd_p_reg_aagc_if_x6     0xA035
+#define reg_aagc_if_x6_pos 0
+#define reg_aagc_if_x6_len 8
+#define reg_aagc_if_x6_lsb 0
+#define xd_p_reg_aagc_if_x7     0xA036
+#define reg_aagc_if_x7_pos 0
+#define reg_aagc_if_x7_len 8
+#define reg_aagc_if_x7_lsb 0
+#define xd_p_reg_aagc_if_x8     0xA037
+#define reg_aagc_if_x8_pos 0
+#define reg_aagc_if_x8_len 8
+#define reg_aagc_if_x8_lsb 0
+#define xd_p_reg_aagc_if_x9     0xA038
+#define reg_aagc_if_x9_pos 0
+#define reg_aagc_if_x9_len 8
+#define reg_aagc_if_x9_lsb 0
+#define xd_p_reg_aagc_if_x10    0xA039
+#define reg_aagc_if_x10_pos 0
+#define reg_aagc_if_x10_len 8
+#define reg_aagc_if_x10_lsb 0
+#define xd_p_reg_aagc_if_x11    0xA03A
+#define reg_aagc_if_x11_pos 0
+#define reg_aagc_if_x11_len 8
+#define reg_aagc_if_x11_lsb 0
+#define xd_p_reg_aagc_if_x12    0xA03B
+#define reg_aagc_if_x12_pos 0
+#define reg_aagc_if_x12_len 8
+#define reg_aagc_if_x12_lsb 0
+#define xd_p_reg_aagc_if_x13    0xA03C
+#define reg_aagc_if_x13_pos 0
+#define reg_aagc_if_x13_len 8
+#define reg_aagc_if_x13_lsb 0
+#define xd_p_reg_aagc_min_rf_ctl_8bit_for_dca   0xA03D
+#define reg_aagc_min_rf_ctl_8bit_for_dca_pos 0
+#define reg_aagc_min_rf_ctl_8bit_for_dca_len 8
+#define reg_aagc_min_rf_ctl_8bit_for_dca_lsb 0
+#define xd_p_reg_aagc_min_if_ctl_8bit_for_dca   0xA03E
+#define reg_aagc_min_if_ctl_8bit_for_dca_pos 0
+#define reg_aagc_min_if_ctl_8bit_for_dca_len 8
+#define reg_aagc_min_if_ctl_8bit_for_dca_lsb 0
+#define xd_r_reg_aagc_total_gain_7_0    0xA070
+#define reg_aagc_total_gain_7_0_pos 0
+#define reg_aagc_total_gain_7_0_len 8
+#define reg_aagc_total_gain_7_0_lsb 0
+#define xd_r_reg_aagc_total_gain_15_8   0xA071
+#define reg_aagc_total_gain_15_8_pos 0
+#define reg_aagc_total_gain_15_8_len 8
+#define reg_aagc_total_gain_15_8_lsb 8
+#define xd_p_reg_aagc_in_sat_cnt_7_0    0xA074
+#define reg_aagc_in_sat_cnt_7_0_pos 0
+#define reg_aagc_in_sat_cnt_7_0_len 8
+#define reg_aagc_in_sat_cnt_7_0_lsb 0
+#define xd_p_reg_aagc_in_sat_cnt_15_8   0xA075
+#define reg_aagc_in_sat_cnt_15_8_pos 0
+#define reg_aagc_in_sat_cnt_15_8_len 8
+#define reg_aagc_in_sat_cnt_15_8_lsb 8
+#define xd_p_reg_aagc_in_sat_cnt_23_16  0xA076
+#define reg_aagc_in_sat_cnt_23_16_pos 0
+#define reg_aagc_in_sat_cnt_23_16_len 8
+#define reg_aagc_in_sat_cnt_23_16_lsb 16
+#define xd_p_reg_aagc_in_sat_cnt_31_24  0xA077
+#define reg_aagc_in_sat_cnt_31_24_pos 0
+#define reg_aagc_in_sat_cnt_31_24_len 8
+#define reg_aagc_in_sat_cnt_31_24_lsb 24
+#define xd_r_reg_aagc_digital_rf_volt_7_0       0xA078
+#define reg_aagc_digital_rf_volt_7_0_pos 0
+#define reg_aagc_digital_rf_volt_7_0_len 8
+#define reg_aagc_digital_rf_volt_7_0_lsb 0
+#define xd_r_reg_aagc_digital_rf_volt_9_8       0xA079
+#define reg_aagc_digital_rf_volt_9_8_pos 0
+#define reg_aagc_digital_rf_volt_9_8_len 2
+#define reg_aagc_digital_rf_volt_9_8_lsb 8
+#define xd_r_reg_aagc_digital_if_volt_7_0       0xA07A
+#define reg_aagc_digital_if_volt_7_0_pos 0
+#define reg_aagc_digital_if_volt_7_0_len 8
+#define reg_aagc_digital_if_volt_7_0_lsb 0
+#define xd_r_reg_aagc_digital_if_volt_9_8       0xA07B
+#define reg_aagc_digital_if_volt_9_8_pos 0
+#define reg_aagc_digital_if_volt_9_8_len 2
+#define reg_aagc_digital_if_volt_9_8_lsb 8
+#define xd_r_reg_aagc_rf_gain   0xA07C
+#define reg_aagc_rf_gain_pos 0
+#define reg_aagc_rf_gain_len 8
+#define reg_aagc_rf_gain_lsb 0
+#define xd_r_reg_aagc_if_gain   0xA07D
+#define reg_aagc_if_gain_pos 0
+#define reg_aagc_if_gain_len 8
+#define reg_aagc_if_gain_lsb 0
+#define xd_p_tinr_imp_indicator 0xA080
+#define tinr_imp_indicator_pos 0
+#define tinr_imp_indicator_len 2
+#define tinr_imp_indicator_lsb 0
+#define xd_p_reg_tinr_fifo_size 0xA080
+#define reg_tinr_fifo_size_pos 2
+#define reg_tinr_fifo_size_len 5
+#define reg_tinr_fifo_size_lsb 0
+#define xd_p_reg_tinr_saturation_cnt_th 0xA081
+#define reg_tinr_saturation_cnt_th_pos 0
+#define reg_tinr_saturation_cnt_th_len 4
+#define reg_tinr_saturation_cnt_th_lsb 0
+#define xd_p_reg_tinr_saturation_th_3_0 0xA081
+#define reg_tinr_saturation_th_3_0_pos 4
+#define reg_tinr_saturation_th_3_0_len 4
+#define reg_tinr_saturation_th_3_0_lsb 0
+#define xd_p_reg_tinr_saturation_th_8_4 0xA082
+#define reg_tinr_saturation_th_8_4_pos 0
+#define reg_tinr_saturation_th_8_4_len 5
+#define reg_tinr_saturation_th_8_4_lsb 4
+#define xd_p_reg_tinr_imp_duration_th_2k_7_0    0xA083
+#define reg_tinr_imp_duration_th_2k_7_0_pos 0
+#define reg_tinr_imp_duration_th_2k_7_0_len 8
+#define reg_tinr_imp_duration_th_2k_7_0_lsb 0
+#define xd_p_reg_tinr_imp_duration_th_2k_8      0xA084
+#define reg_tinr_imp_duration_th_2k_8_pos 0
+#define reg_tinr_imp_duration_th_2k_8_len 1
+#define reg_tinr_imp_duration_th_2k_8_lsb 0
+#define xd_p_reg_tinr_imp_duration_th_8k_7_0    0xA085
+#define reg_tinr_imp_duration_th_8k_7_0_pos 0
+#define reg_tinr_imp_duration_th_8k_7_0_len 8
+#define reg_tinr_imp_duration_th_8k_7_0_lsb 0
+#define xd_p_reg_tinr_imp_duration_th_8k_10_8   0xA086
+#define reg_tinr_imp_duration_th_8k_10_8_pos 0
+#define reg_tinr_imp_duration_th_8k_10_8_len 3
+#define reg_tinr_imp_duration_th_8k_10_8_lsb 8
+#define xd_p_reg_tinr_freq_ratio_6m_7_0 0xA087
+#define reg_tinr_freq_ratio_6m_7_0_pos 0
+#define reg_tinr_freq_ratio_6m_7_0_len 8
+#define reg_tinr_freq_ratio_6m_7_0_lsb 0
+#define xd_p_reg_tinr_freq_ratio_6m_12_8        0xA088
+#define reg_tinr_freq_ratio_6m_12_8_pos 0
+#define reg_tinr_freq_ratio_6m_12_8_len 5
+#define reg_tinr_freq_ratio_6m_12_8_lsb 8
+#define xd_p_reg_tinr_freq_ratio_7m_7_0 0xA089
+#define reg_tinr_freq_ratio_7m_7_0_pos 0
+#define reg_tinr_freq_ratio_7m_7_0_len 8
+#define reg_tinr_freq_ratio_7m_7_0_lsb 0
+#define xd_p_reg_tinr_freq_ratio_7m_12_8        0xA08A
+#define reg_tinr_freq_ratio_7m_12_8_pos 0
+#define reg_tinr_freq_ratio_7m_12_8_len 5
+#define reg_tinr_freq_ratio_7m_12_8_lsb 8
+#define xd_p_reg_tinr_freq_ratio_8m_7_0 0xA08B
+#define reg_tinr_freq_ratio_8m_7_0_pos 0
+#define reg_tinr_freq_ratio_8m_7_0_len 8
+#define reg_tinr_freq_ratio_8m_7_0_lsb 0
+#define xd_p_reg_tinr_freq_ratio_8m_12_8        0xA08C
+#define reg_tinr_freq_ratio_8m_12_8_pos 0
+#define reg_tinr_freq_ratio_8m_12_8_len 5
+#define reg_tinr_freq_ratio_8m_12_8_lsb 8
+#define xd_p_reg_tinr_imp_duration_th_low_2k    0xA08D
+#define reg_tinr_imp_duration_th_low_2k_pos 0
+#define reg_tinr_imp_duration_th_low_2k_len 8
+#define reg_tinr_imp_duration_th_low_2k_lsb 0
+#define xd_p_reg_tinr_imp_duration_th_low_8k    0xA08E
+#define reg_tinr_imp_duration_th_low_8k_pos 0
+#define reg_tinr_imp_duration_th_low_8k_len 8
+#define reg_tinr_imp_duration_th_low_8k_lsb 0
+#define xd_r_reg_tinr_counter_7_0       0xA090
+#define reg_tinr_counter_7_0_pos 0
+#define reg_tinr_counter_7_0_len 8
+#define reg_tinr_counter_7_0_lsb 0
+#define xd_r_reg_tinr_counter_15_8      0xA091
+#define reg_tinr_counter_15_8_pos 0
+#define reg_tinr_counter_15_8_len 8
+#define reg_tinr_counter_15_8_lsb 8
+#define xd_p_reg_tinr_adative_tinr_en   0xA093
+#define reg_tinr_adative_tinr_en_pos 0
+#define reg_tinr_adative_tinr_en_len 1
+#define reg_tinr_adative_tinr_en_lsb 0
+#define xd_p_reg_tinr_peak_fifo_size    0xA093
+#define reg_tinr_peak_fifo_size_pos 1
+#define reg_tinr_peak_fifo_size_len 5
+#define reg_tinr_peak_fifo_size_lsb 0
+#define xd_p_reg_tinr_counter_rst       0xA093
+#define reg_tinr_counter_rst_pos 6
+#define reg_tinr_counter_rst_len 1
+#define reg_tinr_counter_rst_lsb 0
+#define xd_p_reg_tinr_search_period_7_0 0xA094
+#define reg_tinr_search_period_7_0_pos 0
+#define reg_tinr_search_period_7_0_len 8
+#define reg_tinr_search_period_7_0_lsb 0
+#define xd_p_reg_tinr_search_period_15_8        0xA095
+#define reg_tinr_search_period_15_8_pos 0
+#define reg_tinr_search_period_15_8_len 8
+#define reg_tinr_search_period_15_8_lsb 8
+#define xd_p_reg_ccifs_fcw_7_0  0xA0A0
+#define reg_ccifs_fcw_7_0_pos 0
+#define reg_ccifs_fcw_7_0_len 8
+#define reg_ccifs_fcw_7_0_lsb 0
+#define xd_p_reg_ccifs_fcw_12_8 0xA0A1
+#define reg_ccifs_fcw_12_8_pos 0
+#define reg_ccifs_fcw_12_8_len 5
+#define reg_ccifs_fcw_12_8_lsb 8
+#define xd_p_reg_ccifs_spec_inv 0xA0A1
+#define reg_ccifs_spec_inv_pos 5
+#define reg_ccifs_spec_inv_len 1
+#define reg_ccifs_spec_inv_lsb 0
+#define xd_p_reg_gp_trigger     0xA0A2
+#define reg_gp_trigger_pos 0
+#define reg_gp_trigger_len 1
+#define reg_gp_trigger_lsb 0
+#define xd_p_reg_trigger_sel    0xA0A2
+#define reg_trigger_sel_pos 1
+#define reg_trigger_sel_len 2
+#define reg_trigger_sel_lsb 0
+#define xd_p_reg_debug_ofdm     0xA0A2
+#define reg_debug_ofdm_pos 3
+#define reg_debug_ofdm_len 2
+#define reg_debug_ofdm_lsb 0
+#define xd_p_reg_trigger_module_sel     0xA0A3
+#define reg_trigger_module_sel_pos 0
+#define reg_trigger_module_sel_len 6
+#define reg_trigger_module_sel_lsb 0
+#define xd_p_reg_trigger_set_sel        0xA0A4
+#define reg_trigger_set_sel_pos 0
+#define reg_trigger_set_sel_len 6
+#define reg_trigger_set_sel_lsb 0
+#define xd_p_reg_fw_int_mask_n  0xA0A4
+#define reg_fw_int_mask_n_pos 6
+#define reg_fw_int_mask_n_len 1
+#define reg_fw_int_mask_n_lsb 0
+#define xd_p_reg_debug_group    0xA0A5
+#define reg_debug_group_pos 0
+#define reg_debug_group_len 4
+#define reg_debug_group_lsb 0
+#define xd_p_reg_odbg_clk_sel   0xA0A5
+#define reg_odbg_clk_sel_pos 4
+#define reg_odbg_clk_sel_len 2
+#define reg_odbg_clk_sel_lsb 0
+#define xd_p_reg_ccif_sc        0xA0C0
+#define reg_ccif_sc_pos 0
+#define reg_ccif_sc_len 4
+#define reg_ccif_sc_lsb 0
+#define xd_r_reg_ccif_saturate  0xA0C1
+#define reg_ccif_saturate_pos 0
+#define reg_ccif_saturate_len 2
+#define reg_ccif_saturate_lsb 0
+#define xd_r_reg_antif_saturate 0xA0C1
+#define reg_antif_saturate_pos 2
+#define reg_antif_saturate_len 4
+#define reg_antif_saturate_lsb 0
+#define xd_r_reg_acif_saturate  0xA0C2
+#define reg_acif_saturate_pos 0
+#define reg_acif_saturate_len 8
+#define reg_acif_saturate_lsb 0
+#define xd_p_reg_tmr_timer0_threshold_7_0       0xA0C8
+#define reg_tmr_timer0_threshold_7_0_pos 0
+#define reg_tmr_timer0_threshold_7_0_len 8
+#define reg_tmr_timer0_threshold_7_0_lsb 0
+#define xd_p_reg_tmr_timer0_threshold_15_8      0xA0C9
+#define reg_tmr_timer0_threshold_15_8_pos 0
+#define reg_tmr_timer0_threshold_15_8_len 8
+#define reg_tmr_timer0_threshold_15_8_lsb 8
+#define xd_p_reg_tmr_timer0_enable      0xA0CA
+#define reg_tmr_timer0_enable_pos 0
+#define reg_tmr_timer0_enable_len 1
+#define reg_tmr_timer0_enable_lsb 0
+#define xd_p_reg_tmr_timer0_clk_sel     0xA0CA
+#define reg_tmr_timer0_clk_sel_pos 1
+#define reg_tmr_timer0_clk_sel_len 1
+#define reg_tmr_timer0_clk_sel_lsb 0
+#define xd_p_reg_tmr_timer0_int 0xA0CA
+#define reg_tmr_timer0_int_pos 2
+#define reg_tmr_timer0_int_len 1
+#define reg_tmr_timer0_int_lsb 0
+#define xd_p_reg_tmr_timer0_rst 0xA0CA
+#define reg_tmr_timer0_rst_pos 3
+#define reg_tmr_timer0_rst_len 1
+#define reg_tmr_timer0_rst_lsb 0
+#define xd_r_reg_tmr_timer0_count_7_0   0xA0CB
+#define reg_tmr_timer0_count_7_0_pos 0
+#define reg_tmr_timer0_count_7_0_len 8
+#define reg_tmr_timer0_count_7_0_lsb 0
+#define xd_r_reg_tmr_timer0_count_15_8  0xA0CC
+#define reg_tmr_timer0_count_15_8_pos 0
+#define reg_tmr_timer0_count_15_8_len 8
+#define reg_tmr_timer0_count_15_8_lsb 8
+#define xd_p_reg_suspend        0xA0CD
+#define reg_suspend_pos 0
+#define reg_suspend_len 1
+#define reg_suspend_lsb 0
+#define xd_p_reg_suspend_rdy    0xA0CD
+#define reg_suspend_rdy_pos 1
+#define reg_suspend_rdy_len 1
+#define reg_suspend_rdy_lsb 0
+#define xd_p_reg_resume 0xA0CD
+#define reg_resume_pos 2
+#define reg_resume_len 1
+#define reg_resume_lsb 0
+#define xd_p_reg_resume_rdy     0xA0CD
+#define reg_resume_rdy_pos 3
+#define reg_resume_rdy_len 1
+#define reg_resume_rdy_lsb 0
+#define xd_p_reg_fmf    0xA0CE
+#define reg_fmf_pos 0
+#define reg_fmf_len 8
+#define reg_fmf_lsb 0
+#define xd_p_ccid_accumulate_num_2k_7_0 0xA100
+#define ccid_accumulate_num_2k_7_0_pos 0
+#define ccid_accumulate_num_2k_7_0_len 8
+#define ccid_accumulate_num_2k_7_0_lsb 0
+#define xd_p_ccid_accumulate_num_2k_12_8        0xA101
+#define ccid_accumulate_num_2k_12_8_pos 0
+#define ccid_accumulate_num_2k_12_8_len 5
+#define ccid_accumulate_num_2k_12_8_lsb 8
+#define xd_p_ccid_accumulate_num_8k_7_0 0xA102
+#define ccid_accumulate_num_8k_7_0_pos 0
+#define ccid_accumulate_num_8k_7_0_len 8
+#define ccid_accumulate_num_8k_7_0_lsb 0
+#define xd_p_ccid_accumulate_num_8k_14_8        0xA103
+#define ccid_accumulate_num_8k_14_8_pos 0
+#define ccid_accumulate_num_8k_14_8_len 7
+#define ccid_accumulate_num_8k_14_8_lsb 8
+#define xd_p_ccid_desired_level_0       0xA103
+#define ccid_desired_level_0_pos 7
+#define ccid_desired_level_0_len 1
+#define ccid_desired_level_0_lsb 0
+#define xd_p_ccid_desired_level_8_1     0xA104
+#define ccid_desired_level_8_1_pos 0
+#define ccid_desired_level_8_1_len 8
+#define ccid_desired_level_8_1_lsb 1
+#define xd_p_ccid_apply_delay   0xA105
+#define ccid_apply_delay_pos 0
+#define ccid_apply_delay_len 7
+#define ccid_apply_delay_lsb 0
+#define xd_p_ccid_CCID_Threshold1       0xA106
+#define ccid_CCID_Threshold1_pos 0
+#define ccid_CCID_Threshold1_len 8
+#define ccid_CCID_Threshold1_lsb 0
+#define xd_p_ccid_CCID_Threshold2       0xA107
+#define ccid_CCID_Threshold2_pos 0
+#define ccid_CCID_Threshold2_len 8
+#define ccid_CCID_Threshold2_lsb 0
+#define xd_p_reg_ccid_gain_scale        0xA108
+#define reg_ccid_gain_scale_pos 0
+#define reg_ccid_gain_scale_len 4
+#define reg_ccid_gain_scale_lsb 0
+#define xd_p_reg_ccid2_passband_gain_set        0xA108
+#define reg_ccid2_passband_gain_set_pos 4
+#define reg_ccid2_passband_gain_set_len 4
+#define reg_ccid2_passband_gain_set_lsb 0
+#define xd_r_ccid_multiplier_7_0        0xA109
+#define ccid_multiplier_7_0_pos 0
+#define ccid_multiplier_7_0_len 8
+#define ccid_multiplier_7_0_lsb 0
+#define xd_r_ccid_multiplier_15_8       0xA10A
+#define ccid_multiplier_15_8_pos 0
+#define ccid_multiplier_15_8_len 8
+#define ccid_multiplier_15_8_lsb 8
+#define xd_r_ccid_right_shift_bits      0xA10B
+#define ccid_right_shift_bits_pos 0
+#define ccid_right_shift_bits_len 4
+#define ccid_right_shift_bits_lsb 0
+#define xd_r_reg_ccid_sx_7_0    0xA10C
+#define reg_ccid_sx_7_0_pos 0
+#define reg_ccid_sx_7_0_len 8
+#define reg_ccid_sx_7_0_lsb 0
+#define xd_r_reg_ccid_sx_15_8   0xA10D
+#define reg_ccid_sx_15_8_pos 0
+#define reg_ccid_sx_15_8_len 8
+#define reg_ccid_sx_15_8_lsb 8
+#define xd_r_reg_ccid_sx_21_16  0xA10E
+#define reg_ccid_sx_21_16_pos 0
+#define reg_ccid_sx_21_16_len 6
+#define reg_ccid_sx_21_16_lsb 16
+#define xd_r_reg_ccid_sy_7_0    0xA110
+#define reg_ccid_sy_7_0_pos 0
+#define reg_ccid_sy_7_0_len 8
+#define reg_ccid_sy_7_0_lsb 0
+#define xd_r_reg_ccid_sy_15_8   0xA111
+#define reg_ccid_sy_15_8_pos 0
+#define reg_ccid_sy_15_8_len 8
+#define reg_ccid_sy_15_8_lsb 8
+#define xd_r_reg_ccid_sy_23_16  0xA112
+#define reg_ccid_sy_23_16_pos 0
+#define reg_ccid_sy_23_16_len 8
+#define reg_ccid_sy_23_16_lsb 16
+#define xd_r_reg_ccid2_sz_7_0   0xA114
+#define reg_ccid2_sz_7_0_pos 0
+#define reg_ccid2_sz_7_0_len 8
+#define reg_ccid2_sz_7_0_lsb 0
+#define xd_r_reg_ccid2_sz_15_8  0xA115
+#define reg_ccid2_sz_15_8_pos 0
+#define reg_ccid2_sz_15_8_len 8
+#define reg_ccid2_sz_15_8_lsb 8
+#define xd_r_reg_ccid2_sz_23_16 0xA116
+#define reg_ccid2_sz_23_16_pos 0
+#define reg_ccid2_sz_23_16_len 8
+#define reg_ccid2_sz_23_16_lsb 16
+#define xd_r_reg_ccid2_sz_25_24 0xA117
+#define reg_ccid2_sz_25_24_pos 0
+#define reg_ccid2_sz_25_24_len 2
+#define reg_ccid2_sz_25_24_lsb 24
+#define xd_r_reg_ccid2_sy_7_0   0xA118
+#define reg_ccid2_sy_7_0_pos 0
+#define reg_ccid2_sy_7_0_len 8
+#define reg_ccid2_sy_7_0_lsb 0
+#define xd_r_reg_ccid2_sy_15_8  0xA119
+#define reg_ccid2_sy_15_8_pos 0
+#define reg_ccid2_sy_15_8_len 8
+#define reg_ccid2_sy_15_8_lsb 8
+#define xd_r_reg_ccid2_sy_23_16 0xA11A
+#define reg_ccid2_sy_23_16_pos 0
+#define reg_ccid2_sy_23_16_len 8
+#define reg_ccid2_sy_23_16_lsb 16
+#define xd_r_reg_ccid2_sy_25_24 0xA11B
+#define reg_ccid2_sy_25_24_pos 0
+#define reg_ccid2_sy_25_24_len 2
+#define reg_ccid2_sy_25_24_lsb 24
+#define xd_p_dagc1_accumulate_num_2k_7_0        0xA120
+#define dagc1_accumulate_num_2k_7_0_pos 0
+#define dagc1_accumulate_num_2k_7_0_len 8
+#define dagc1_accumulate_num_2k_7_0_lsb 0
+#define xd_p_dagc1_accumulate_num_2k_12_8       0xA121
+#define dagc1_accumulate_num_2k_12_8_pos 0
+#define dagc1_accumulate_num_2k_12_8_len 5
+#define dagc1_accumulate_num_2k_12_8_lsb 8
+#define xd_p_dagc1_accumulate_num_8k_7_0        0xA122
+#define dagc1_accumulate_num_8k_7_0_pos 0
+#define dagc1_accumulate_num_8k_7_0_len 8
+#define dagc1_accumulate_num_8k_7_0_lsb 0
+#define xd_p_dagc1_accumulate_num_8k_14_8       0xA123
+#define dagc1_accumulate_num_8k_14_8_pos 0
+#define dagc1_accumulate_num_8k_14_8_len 7
+#define dagc1_accumulate_num_8k_14_8_lsb 8
+#define xd_p_dagc1_desired_level_0      0xA123
+#define dagc1_desired_level_0_pos 7
+#define dagc1_desired_level_0_len 1
+#define dagc1_desired_level_0_lsb 0
+#define xd_p_dagc1_desired_level_8_1    0xA124
+#define dagc1_desired_level_8_1_pos 0
+#define dagc1_desired_level_8_1_len 8
+#define dagc1_desired_level_8_1_lsb 1
+#define xd_p_dagc1_apply_delay  0xA125
+#define dagc1_apply_delay_pos 0
+#define dagc1_apply_delay_len 7
+#define dagc1_apply_delay_lsb 0
+#define xd_p_dagc1_bypass_scale_ctl     0xA126
+#define dagc1_bypass_scale_ctl_pos 0
+#define dagc1_bypass_scale_ctl_len 2
+#define dagc1_bypass_scale_ctl_lsb 0
+#define xd_p_reg_dagc1_in_sat_cnt_7_0   0xA127
+#define reg_dagc1_in_sat_cnt_7_0_pos 0
+#define reg_dagc1_in_sat_cnt_7_0_len 8
+#define reg_dagc1_in_sat_cnt_7_0_lsb 0
+#define xd_p_reg_dagc1_in_sat_cnt_15_8  0xA128
+#define reg_dagc1_in_sat_cnt_15_8_pos 0
+#define reg_dagc1_in_sat_cnt_15_8_len 8
+#define reg_dagc1_in_sat_cnt_15_8_lsb 8
+#define xd_p_reg_dagc1_in_sat_cnt_23_16 0xA129
+#define reg_dagc1_in_sat_cnt_23_16_pos 0
+#define reg_dagc1_in_sat_cnt_23_16_len 8
+#define reg_dagc1_in_sat_cnt_23_16_lsb 16
+#define xd_p_reg_dagc1_in_sat_cnt_31_24 0xA12A
+#define reg_dagc1_in_sat_cnt_31_24_pos 0
+#define reg_dagc1_in_sat_cnt_31_24_len 8
+#define reg_dagc1_in_sat_cnt_31_24_lsb 24
+#define xd_p_reg_dagc1_out_sat_cnt_7_0  0xA12B
+#define reg_dagc1_out_sat_cnt_7_0_pos 0
+#define reg_dagc1_out_sat_cnt_7_0_len 8
+#define reg_dagc1_out_sat_cnt_7_0_lsb 0
+#define xd_p_reg_dagc1_out_sat_cnt_15_8 0xA12C
+#define reg_dagc1_out_sat_cnt_15_8_pos 0
+#define reg_dagc1_out_sat_cnt_15_8_len 8
+#define reg_dagc1_out_sat_cnt_15_8_lsb 8
+#define xd_p_reg_dagc1_out_sat_cnt_23_16        0xA12D
+#define reg_dagc1_out_sat_cnt_23_16_pos 0
+#define reg_dagc1_out_sat_cnt_23_16_len 8
+#define reg_dagc1_out_sat_cnt_23_16_lsb 16
+#define xd_p_reg_dagc1_out_sat_cnt_31_24        0xA12E
+#define reg_dagc1_out_sat_cnt_31_24_pos 0
+#define reg_dagc1_out_sat_cnt_31_24_len 8
+#define reg_dagc1_out_sat_cnt_31_24_lsb 24
+#define xd_r_dagc1_multiplier_7_0       0xA136
+#define dagc1_multiplier_7_0_pos 0
+#define dagc1_multiplier_7_0_len 8
+#define dagc1_multiplier_7_0_lsb 0
+#define xd_r_dagc1_multiplier_15_8      0xA137
+#define dagc1_multiplier_15_8_pos 0
+#define dagc1_multiplier_15_8_len 8
+#define dagc1_multiplier_15_8_lsb 8
+#define xd_r_dagc1_right_shift_bits     0xA138
+#define dagc1_right_shift_bits_pos 0
+#define dagc1_right_shift_bits_len 4
+#define dagc1_right_shift_bits_lsb 0
+#define xd_p_reg_bfs_fcw_7_0    0xA140
+#define reg_bfs_fcw_7_0_pos 0
+#define reg_bfs_fcw_7_0_len 8
+#define reg_bfs_fcw_7_0_lsb 0
+#define xd_p_reg_bfs_fcw_15_8   0xA141
+#define reg_bfs_fcw_15_8_pos 0
+#define reg_bfs_fcw_15_8_len 8
+#define reg_bfs_fcw_15_8_lsb 8
+#define xd_p_reg_bfs_fcw_22_16  0xA142
+#define reg_bfs_fcw_22_16_pos 0
+#define reg_bfs_fcw_22_16_len 7
+#define reg_bfs_fcw_22_16_lsb 16
+#define xd_p_reg_antif_sf_7_0   0xA144
+#define reg_antif_sf_7_0_pos 0
+#define reg_antif_sf_7_0_len 8
+#define reg_antif_sf_7_0_lsb 0
+#define xd_p_reg_antif_sf_11_8  0xA145
+#define reg_antif_sf_11_8_pos 0
+#define reg_antif_sf_11_8_len 4
+#define reg_antif_sf_11_8_lsb 8
+#define xd_r_bfs_fcw_q_7_0      0xA150
+#define bfs_fcw_q_7_0_pos 0
+#define bfs_fcw_q_7_0_len 8
+#define bfs_fcw_q_7_0_lsb 0
+#define xd_r_bfs_fcw_q_15_8     0xA151
+#define bfs_fcw_q_15_8_pos 0
+#define bfs_fcw_q_15_8_len 8
+#define bfs_fcw_q_15_8_lsb 8
+#define xd_r_bfs_fcw_q_22_16    0xA152
+#define bfs_fcw_q_22_16_pos 0
+#define bfs_fcw_q_22_16_len 7
+#define bfs_fcw_q_22_16_lsb 16
+#define xd_p_reg_dca_enu        0xA160
+#define reg_dca_enu_pos 0
+#define reg_dca_enu_len 1
+#define reg_dca_enu_lsb 0
+#define xd_p_reg_dca_enl        0xA160
+#define reg_dca_enl_pos 1
+#define reg_dca_enl_len 1
+#define reg_dca_enl_lsb 0
+#define xd_p_reg_dca_lower_chip 0xA160
+#define reg_dca_lower_chip_pos 2
+#define reg_dca_lower_chip_len 1
+#define reg_dca_lower_chip_lsb 0
+#define xd_p_reg_dca_upper_chip 0xA160
+#define reg_dca_upper_chip_pos 3
+#define reg_dca_upper_chip_len 1
+#define reg_dca_upper_chip_lsb 0
+#define xd_p_reg_dca_platch     0xA160
+#define reg_dca_platch_pos 4
+#define reg_dca_platch_len 1
+#define reg_dca_platch_lsb 0
+#define xd_p_reg_dca_th 0xA161
+#define reg_dca_th_pos 0
+#define reg_dca_th_len 5
+#define reg_dca_th_lsb 0
+#define xd_p_reg_dca_scale      0xA162
+#define reg_dca_scale_pos 0
+#define reg_dca_scale_len 4
+#define reg_dca_scale_lsb 0
+#define xd_p_reg_dca_tone_7_0   0xA163
+#define reg_dca_tone_7_0_pos 0
+#define reg_dca_tone_7_0_len 8
+#define reg_dca_tone_7_0_lsb 0
+#define xd_p_reg_dca_tone_12_8  0xA164
+#define reg_dca_tone_12_8_pos 0
+#define reg_dca_tone_12_8_len 5
+#define reg_dca_tone_12_8_lsb 8
+#define xd_p_reg_dca_time_7_0   0xA165
+#define reg_dca_time_7_0_pos 0
+#define reg_dca_time_7_0_len 8
+#define reg_dca_time_7_0_lsb 0
+#define xd_p_reg_dca_time_15_8  0xA166
+#define reg_dca_time_15_8_pos 0
+#define reg_dca_time_15_8_len 8
+#define reg_dca_time_15_8_lsb 8
+#define xd_r_dcasm      0xA167
+#define dcasm_pos 0
+#define dcasm_len 3
+#define dcasm_lsb 0
+#define xd_p_reg_qnt_valuew_7_0 0xA168
+#define reg_qnt_valuew_7_0_pos 0
+#define reg_qnt_valuew_7_0_len 8
+#define reg_qnt_valuew_7_0_lsb 0
+#define xd_p_reg_qnt_valuew_10_8        0xA169
+#define reg_qnt_valuew_10_8_pos 0
+#define reg_qnt_valuew_10_8_len 3
+#define reg_qnt_valuew_10_8_lsb 8
+#define xd_p_dca_sbx_gain_diff_7_0      0xA16A
+#define dca_sbx_gain_diff_7_0_pos 0
+#define dca_sbx_gain_diff_7_0_len 8
+#define dca_sbx_gain_diff_7_0_lsb 0
+#define xd_p_dca_sbx_gain_diff_9_8      0xA16B
+#define dca_sbx_gain_diff_9_8_pos 0
+#define dca_sbx_gain_diff_9_8_len 2
+#define dca_sbx_gain_diff_9_8_lsb 8
+#define xd_p_reg_dca_stand_alone        0xA16C
+#define reg_dca_stand_alone_pos 0
+#define reg_dca_stand_alone_len 1
+#define reg_dca_stand_alone_lsb 0
+#define xd_p_reg_dca_upper_out_en       0xA16C
+#define reg_dca_upper_out_en_pos 1
+#define reg_dca_upper_out_en_len 1
+#define reg_dca_upper_out_en_lsb 0
+#define xd_p_reg_dca_rc_en      0xA16C
+#define reg_dca_rc_en_pos 2
+#define reg_dca_rc_en_len 1
+#define reg_dca_rc_en_lsb 0
+#define xd_p_reg_dca_retrain_send       0xA16C
+#define reg_dca_retrain_send_pos 3
+#define reg_dca_retrain_send_len 1
+#define reg_dca_retrain_send_lsb 0
+#define xd_p_reg_dca_retrain_rec        0xA16C
+#define reg_dca_retrain_rec_pos 4
+#define reg_dca_retrain_rec_len 1
+#define reg_dca_retrain_rec_lsb 0
+#define xd_p_reg_dca_api_tpsrdy 0xA16C
+#define reg_dca_api_tpsrdy_pos 5
+#define reg_dca_api_tpsrdy_len 1
+#define reg_dca_api_tpsrdy_lsb 0
+#define xd_p_reg_dca_symbol_gap 0xA16D
+#define reg_dca_symbol_gap_pos 0
+#define reg_dca_symbol_gap_len 4
+#define reg_dca_symbol_gap_lsb 0
+#define xd_p_reg_qnt_nfvaluew_7_0       0xA16E
+#define reg_qnt_nfvaluew_7_0_pos 0
+#define reg_qnt_nfvaluew_7_0_len 8
+#define reg_qnt_nfvaluew_7_0_lsb 0
+#define xd_p_reg_qnt_nfvaluew_10_8      0xA16F
+#define reg_qnt_nfvaluew_10_8_pos 0
+#define reg_qnt_nfvaluew_10_8_len 3
+#define reg_qnt_nfvaluew_10_8_lsb 8
+#define xd_p_reg_qnt_flatness_thr_7_0   0xA170
+#define reg_qnt_flatness_thr_7_0_pos 0
+#define reg_qnt_flatness_thr_7_0_len 8
+#define reg_qnt_flatness_thr_7_0_lsb 0
+#define xd_p_reg_qnt_flatness_thr_9_8   0xA171
+#define reg_qnt_flatness_thr_9_8_pos 0
+#define reg_qnt_flatness_thr_9_8_len 2
+#define reg_qnt_flatness_thr_9_8_lsb 8
+#define xd_p_reg_dca_tone_idx_5_0       0xA171
+#define reg_dca_tone_idx_5_0_pos 2
+#define reg_dca_tone_idx_5_0_len 6
+#define reg_dca_tone_idx_5_0_lsb 0
+#define xd_p_reg_dca_tone_idx_12_6      0xA172
+#define reg_dca_tone_idx_12_6_pos 0
+#define reg_dca_tone_idx_12_6_len 7
+#define reg_dca_tone_idx_12_6_lsb 6
+#define xd_p_reg_dca_data_vld   0xA173
+#define reg_dca_data_vld_pos 0
+#define reg_dca_data_vld_len 1
+#define reg_dca_data_vld_lsb 0
+#define xd_p_reg_dca_read_update        0xA173
+#define reg_dca_read_update_pos 1
+#define reg_dca_read_update_len 1
+#define reg_dca_read_update_lsb 0
+#define xd_r_reg_dca_data_re_5_0        0xA173
+#define reg_dca_data_re_5_0_pos 2
+#define reg_dca_data_re_5_0_len 6
+#define reg_dca_data_re_5_0_lsb 0
+#define xd_r_reg_dca_data_re_10_6       0xA174
+#define reg_dca_data_re_10_6_pos 0
+#define reg_dca_data_re_10_6_len 5
+#define reg_dca_data_re_10_6_lsb 6
+#define xd_r_reg_dca_data_im_7_0        0xA175
+#define reg_dca_data_im_7_0_pos 0
+#define reg_dca_data_im_7_0_len 8
+#define reg_dca_data_im_7_0_lsb 0
+#define xd_r_reg_dca_data_im_10_8       0xA176
+#define reg_dca_data_im_10_8_pos 0
+#define reg_dca_data_im_10_8_len 3
+#define reg_dca_data_im_10_8_lsb 8
+#define xd_r_reg_dca_data_h2_7_0        0xA178
+#define reg_dca_data_h2_7_0_pos 0
+#define reg_dca_data_h2_7_0_len 8
+#define reg_dca_data_h2_7_0_lsb 0
+#define xd_r_reg_dca_data_h2_9_8        0xA179
+#define reg_dca_data_h2_9_8_pos 0
+#define reg_dca_data_h2_9_8_len 2
+#define reg_dca_data_h2_9_8_lsb 8
+#define xd_p_reg_f_adc_7_0      0xA180
+#define reg_f_adc_7_0_pos 0
+#define reg_f_adc_7_0_len 8
+#define reg_f_adc_7_0_lsb 0
+#define xd_p_reg_f_adc_15_8     0xA181
+#define reg_f_adc_15_8_pos 0
+#define reg_f_adc_15_8_len 8
+#define reg_f_adc_15_8_lsb 8
+#define xd_p_reg_f_adc_23_16    0xA182
+#define reg_f_adc_23_16_pos 0
+#define reg_f_adc_23_16_len 8
+#define reg_f_adc_23_16_lsb 16
+#define xd_r_intp_mu_7_0        0xA190
+#define intp_mu_7_0_pos 0
+#define intp_mu_7_0_len 8
+#define intp_mu_7_0_lsb 0
+#define xd_r_intp_mu_15_8       0xA191
+#define intp_mu_15_8_pos 0
+#define intp_mu_15_8_len 8
+#define intp_mu_15_8_lsb 8
+#define xd_r_intp_mu_19_16      0xA192
+#define intp_mu_19_16_pos 0
+#define intp_mu_19_16_len 4
+#define intp_mu_19_16_lsb 16
+#define xd_p_reg_agc_rst        0xA1A0
+#define reg_agc_rst_pos 0
+#define reg_agc_rst_len 1
+#define reg_agc_rst_lsb 0
+#define xd_p_rf_agc_en  0xA1A0
+#define rf_agc_en_pos 1
+#define rf_agc_en_len 1
+#define rf_agc_en_lsb 0
+#define xd_p_rf_agc_dis 0xA1A0
+#define rf_agc_dis_pos 2
+#define rf_agc_dis_len 1
+#define rf_agc_dis_lsb 0
+#define xd_p_if_agc_rst 0xA1A0
+#define if_agc_rst_pos 3
+#define if_agc_rst_len 1
+#define if_agc_rst_lsb 0
+#define xd_p_if_agc_en  0xA1A0
+#define if_agc_en_pos 4
+#define if_agc_en_len 1
+#define if_agc_en_lsb 0
+#define xd_p_if_agc_dis 0xA1A0
+#define if_agc_dis_pos 5
+#define if_agc_dis_len 1
+#define if_agc_dis_lsb 0
+#define xd_p_agc_lock   0xA1A0
+#define agc_lock_pos 6
+#define agc_lock_len 1
+#define agc_lock_lsb 0
+#define xd_p_reg_tinr_rst       0xA1A1
+#define reg_tinr_rst_pos 0
+#define reg_tinr_rst_len 1
+#define reg_tinr_rst_lsb 0
+#define xd_p_reg_tinr_en        0xA1A1
+#define reg_tinr_en_pos 1
+#define reg_tinr_en_len 1
+#define reg_tinr_en_lsb 0
+#define xd_p_reg_ccifs_en       0xA1A2
+#define reg_ccifs_en_pos 0
+#define reg_ccifs_en_len 1
+#define reg_ccifs_en_lsb 0
+#define xd_p_reg_ccifs_dis      0xA1A2
+#define reg_ccifs_dis_pos 1
+#define reg_ccifs_dis_len 1
+#define reg_ccifs_dis_lsb 0
+#define xd_p_reg_ccifs_rst      0xA1A2
+#define reg_ccifs_rst_pos 2
+#define reg_ccifs_rst_len 1
+#define reg_ccifs_rst_lsb 0
+#define xd_p_reg_ccifs_byp      0xA1A2
+#define reg_ccifs_byp_pos 3
+#define reg_ccifs_byp_len 1
+#define reg_ccifs_byp_lsb 0
+#define xd_p_reg_ccif_en        0xA1A3
+#define reg_ccif_en_pos 0
+#define reg_ccif_en_len 1
+#define reg_ccif_en_lsb 0
+#define xd_p_reg_ccif_dis       0xA1A3
+#define reg_ccif_dis_pos 1
+#define reg_ccif_dis_len 1
+#define reg_ccif_dis_lsb 0
+#define xd_p_reg_ccif_rst       0xA1A3
+#define reg_ccif_rst_pos 2
+#define reg_ccif_rst_len 1
+#define reg_ccif_rst_lsb 0
+#define xd_p_reg_ccif_byp       0xA1A3
+#define reg_ccif_byp_pos 3
+#define reg_ccif_byp_len 1
+#define reg_ccif_byp_lsb 0
+#define xd_p_dagc1_rst  0xA1A4
+#define dagc1_rst_pos 0
+#define dagc1_rst_len 1
+#define dagc1_rst_lsb 0
+#define xd_p_dagc1_en   0xA1A4
+#define dagc1_en_pos 1
+#define dagc1_en_len 1
+#define dagc1_en_lsb 0
+#define xd_p_dagc1_mode 0xA1A4
+#define dagc1_mode_pos 2
+#define dagc1_mode_len 2
+#define dagc1_mode_lsb 0
+#define xd_p_dagc1_done 0xA1A4
+#define dagc1_done_pos 4
+#define dagc1_done_len 1
+#define dagc1_done_lsb 0
+#define xd_p_ccid_rst   0xA1A5
+#define ccid_rst_pos 0
+#define ccid_rst_len 1
+#define ccid_rst_lsb 0
+#define xd_p_ccid_en    0xA1A5
+#define ccid_en_pos 1
+#define ccid_en_len 1
+#define ccid_en_lsb 0
+#define xd_p_ccid_mode  0xA1A5
+#define ccid_mode_pos 2
+#define ccid_mode_len 2
+#define ccid_mode_lsb 0
+#define xd_p_ccid_done  0xA1A5
+#define ccid_done_pos 4
+#define ccid_done_len 1
+#define ccid_done_lsb 0
+#define xd_r_ccid_deted 0xA1A5
+#define ccid_deted_pos 5
+#define ccid_deted_len 1
+#define ccid_deted_lsb 0
+#define xd_p_ccid2_en   0xA1A5
+#define ccid2_en_pos 6
+#define ccid2_en_len 1
+#define ccid2_en_lsb 0
+#define xd_p_ccid2_done 0xA1A5
+#define ccid2_done_pos 7
+#define ccid2_done_len 1
+#define ccid2_done_lsb 0
+#define xd_p_reg_bfs_en 0xA1A6
+#define reg_bfs_en_pos 0
+#define reg_bfs_en_len 1
+#define reg_bfs_en_lsb 0
+#define xd_p_reg_bfs_dis        0xA1A6
+#define reg_bfs_dis_pos 1
+#define reg_bfs_dis_len 1
+#define reg_bfs_dis_lsb 0
+#define xd_p_reg_bfs_rst        0xA1A6
+#define reg_bfs_rst_pos 2
+#define reg_bfs_rst_len 1
+#define reg_bfs_rst_lsb 0
+#define xd_p_reg_bfs_byp        0xA1A6
+#define reg_bfs_byp_pos 3
+#define reg_bfs_byp_len 1
+#define reg_bfs_byp_lsb 0
+#define xd_p_reg_antif_en       0xA1A7
+#define reg_antif_en_pos 0
+#define reg_antif_en_len 1
+#define reg_antif_en_lsb 0
+#define xd_p_reg_antif_dis      0xA1A7
+#define reg_antif_dis_pos 1
+#define reg_antif_dis_len 1
+#define reg_antif_dis_lsb 0
+#define xd_p_reg_antif_rst      0xA1A7
+#define reg_antif_rst_pos 2
+#define reg_antif_rst_len 1
+#define reg_antif_rst_lsb 0
+#define xd_p_reg_antif_byp      0xA1A7
+#define reg_antif_byp_pos 3
+#define reg_antif_byp_len 1
+#define reg_antif_byp_lsb 0
+#define xd_p_intp_en    0xA1A8
+#define intp_en_pos 0
+#define intp_en_len 1
+#define intp_en_lsb 0
+#define xd_p_intp_dis   0xA1A8
+#define intp_dis_pos 1
+#define intp_dis_len 1
+#define intp_dis_lsb 0
+#define xd_p_intp_rst   0xA1A8
+#define intp_rst_pos 2
+#define intp_rst_len 1
+#define intp_rst_lsb 0
+#define xd_p_intp_byp   0xA1A8
+#define intp_byp_pos 3
+#define intp_byp_len 1
+#define intp_byp_lsb 0
+#define xd_p_reg_acif_en        0xA1A9
+#define reg_acif_en_pos 0
+#define reg_acif_en_len 1
+#define reg_acif_en_lsb 0
+#define xd_p_reg_acif_dis       0xA1A9
+#define reg_acif_dis_pos 1
+#define reg_acif_dis_len 1
+#define reg_acif_dis_lsb 0
+#define xd_p_reg_acif_rst       0xA1A9
+#define reg_acif_rst_pos 2
+#define reg_acif_rst_len 1
+#define reg_acif_rst_lsb 0
+#define xd_p_reg_acif_byp       0xA1A9
+#define reg_acif_byp_pos 3
+#define reg_acif_byp_len 1
+#define reg_acif_byp_lsb 0
+#define xd_p_reg_acif_sync_mode 0xA1A9
+#define reg_acif_sync_mode_pos 4
+#define reg_acif_sync_mode_len 1
+#define reg_acif_sync_mode_lsb 0
+#define xd_p_dagc2_rst  0xA1AA
+#define dagc2_rst_pos 0
+#define dagc2_rst_len 1
+#define dagc2_rst_lsb 0
+#define xd_p_dagc2_en   0xA1AA
+#define dagc2_en_pos 1
+#define dagc2_en_len 1
+#define dagc2_en_lsb 0
+#define xd_p_dagc2_mode 0xA1AA
+#define dagc2_mode_pos 2
+#define dagc2_mode_len 2
+#define dagc2_mode_lsb 0
+#define xd_p_dagc2_done 0xA1AA
+#define dagc2_done_pos 4
+#define dagc2_done_len 1
+#define dagc2_done_lsb 0
+#define xd_p_reg_dca_en 0xA1AB
+#define reg_dca_en_pos 0
+#define reg_dca_en_len 1
+#define reg_dca_en_lsb 0
+#define xd_p_dagc2_accumulate_num_2k_7_0        0xA1C0
+#define dagc2_accumulate_num_2k_7_0_pos 0
+#define dagc2_accumulate_num_2k_7_0_len 8
+#define dagc2_accumulate_num_2k_7_0_lsb 0
+#define xd_p_dagc2_accumulate_num_2k_12_8       0xA1C1
+#define dagc2_accumulate_num_2k_12_8_pos 0
+#define dagc2_accumulate_num_2k_12_8_len 5
+#define dagc2_accumulate_num_2k_12_8_lsb 8
+#define xd_p_dagc2_accumulate_num_8k_7_0        0xA1C2
+#define dagc2_accumulate_num_8k_7_0_pos 0
+#define dagc2_accumulate_num_8k_7_0_len 8
+#define dagc2_accumulate_num_8k_7_0_lsb 0
+#define xd_p_dagc2_accumulate_num_8k_12_8       0xA1C3
+#define dagc2_accumulate_num_8k_12_8_pos 0
+#define dagc2_accumulate_num_8k_12_8_len 5
+#define dagc2_accumulate_num_8k_12_8_lsb 8
+#define xd_p_dagc2_desired_level_2_0    0xA1C3
+#define dagc2_desired_level_2_0_pos 5
+#define dagc2_desired_level_2_0_len 3
+#define dagc2_desired_level_2_0_lsb 0
+#define xd_p_dagc2_desired_level_8_3    0xA1C4
+#define dagc2_desired_level_8_3_pos 0
+#define dagc2_desired_level_8_3_len 6
+#define dagc2_desired_level_8_3_lsb 3
+#define xd_p_dagc2_apply_delay  0xA1C5
+#define dagc2_apply_delay_pos 0
+#define dagc2_apply_delay_len 7
+#define dagc2_apply_delay_lsb 0
+#define xd_p_dagc2_bypass_scale_ctl     0xA1C6
+#define dagc2_bypass_scale_ctl_pos 0
+#define dagc2_bypass_scale_ctl_len 3
+#define dagc2_bypass_scale_ctl_lsb 0
+#define xd_p_dagc2_programmable_shift1  0xA1C7
+#define dagc2_programmable_shift1_pos 0
+#define dagc2_programmable_shift1_len 8
+#define dagc2_programmable_shift1_lsb 0
+#define xd_p_dagc2_programmable_shift2  0xA1C8
+#define dagc2_programmable_shift2_pos 0
+#define dagc2_programmable_shift2_len 8
+#define dagc2_programmable_shift2_lsb 0
+#define xd_p_reg_dagc2_in_sat_cnt_7_0   0xA1C9
+#define reg_dagc2_in_sat_cnt_7_0_pos 0
+#define reg_dagc2_in_sat_cnt_7_0_len 8
+#define reg_dagc2_in_sat_cnt_7_0_lsb 0
+#define xd_p_reg_dagc2_in_sat_cnt_15_8  0xA1CA
+#define reg_dagc2_in_sat_cnt_15_8_pos 0
+#define reg_dagc2_in_sat_cnt_15_8_len 8
+#define reg_dagc2_in_sat_cnt_15_8_lsb 8
+#define xd_p_reg_dagc2_in_sat_cnt_23_16 0xA1CB
+#define reg_dagc2_in_sat_cnt_23_16_pos 0
+#define reg_dagc2_in_sat_cnt_23_16_len 8
+#define reg_dagc2_in_sat_cnt_23_16_lsb 16
+#define xd_p_reg_dagc2_in_sat_cnt_31_24 0xA1CC
+#define reg_dagc2_in_sat_cnt_31_24_pos 0
+#define reg_dagc2_in_sat_cnt_31_24_len 8
+#define reg_dagc2_in_sat_cnt_31_24_lsb 24
+#define xd_p_reg_dagc2_out_sat_cnt_7_0  0xA1CD
+#define reg_dagc2_out_sat_cnt_7_0_pos 0
+#define reg_dagc2_out_sat_cnt_7_0_len 8
+#define reg_dagc2_out_sat_cnt_7_0_lsb 0
+#define xd_p_reg_dagc2_out_sat_cnt_15_8 0xA1CE
+#define reg_dagc2_out_sat_cnt_15_8_pos 0
+#define reg_dagc2_out_sat_cnt_15_8_len 8
+#define reg_dagc2_out_sat_cnt_15_8_lsb 8
+#define xd_p_reg_dagc2_out_sat_cnt_23_16        0xA1CF
+#define reg_dagc2_out_sat_cnt_23_16_pos 0
+#define reg_dagc2_out_sat_cnt_23_16_len 8
+#define reg_dagc2_out_sat_cnt_23_16_lsb 16
+#define xd_p_reg_dagc2_out_sat_cnt_31_24        0xA1D0
+#define reg_dagc2_out_sat_cnt_31_24_pos 0
+#define reg_dagc2_out_sat_cnt_31_24_len 8
+#define reg_dagc2_out_sat_cnt_31_24_lsb 24
+#define xd_r_dagc2_multiplier_7_0       0xA1D6
+#define dagc2_multiplier_7_0_pos 0
+#define dagc2_multiplier_7_0_len 8
+#define dagc2_multiplier_7_0_lsb 0
+#define xd_r_dagc2_multiplier_15_8      0xA1D7
+#define dagc2_multiplier_15_8_pos 0
+#define dagc2_multiplier_15_8_len 8
+#define dagc2_multiplier_15_8_lsb 8
+#define xd_r_dagc2_right_shift_bits     0xA1D8
+#define dagc2_right_shift_bits_pos 0
+#define dagc2_right_shift_bits_len 4
+#define dagc2_right_shift_bits_lsb 0
+#define xd_p_cfoe_NS_coeff1_7_0 0xA200
+#define cfoe_NS_coeff1_7_0_pos 0
+#define cfoe_NS_coeff1_7_0_len 8
+#define cfoe_NS_coeff1_7_0_lsb 0
+#define xd_p_cfoe_NS_coeff1_15_8        0xA201
+#define cfoe_NS_coeff1_15_8_pos 0
+#define cfoe_NS_coeff1_15_8_len 8
+#define cfoe_NS_coeff1_15_8_lsb 8
+#define xd_p_cfoe_NS_coeff1_23_16       0xA202
+#define cfoe_NS_coeff1_23_16_pos 0
+#define cfoe_NS_coeff1_23_16_len 8
+#define cfoe_NS_coeff1_23_16_lsb 16
+#define xd_p_cfoe_NS_coeff1_25_24       0xA203
+#define cfoe_NS_coeff1_25_24_pos 0
+#define cfoe_NS_coeff1_25_24_len 2
+#define cfoe_NS_coeff1_25_24_lsb 24
+#define xd_p_cfoe_NS_coeff2_5_0 0xA203
+#define cfoe_NS_coeff2_5_0_pos 2
+#define cfoe_NS_coeff2_5_0_len 6
+#define cfoe_NS_coeff2_5_0_lsb 0
+#define xd_p_cfoe_NS_coeff2_13_6        0xA204
+#define cfoe_NS_coeff2_13_6_pos 0
+#define cfoe_NS_coeff2_13_6_len 8
+#define cfoe_NS_coeff2_13_6_lsb 6
+#define xd_p_cfoe_NS_coeff2_21_14       0xA205
+#define cfoe_NS_coeff2_21_14_pos 0
+#define cfoe_NS_coeff2_21_14_len 8
+#define cfoe_NS_coeff2_21_14_lsb 14
+#define xd_p_cfoe_NS_coeff2_24_22       0xA206
+#define cfoe_NS_coeff2_24_22_pos 0
+#define cfoe_NS_coeff2_24_22_len 3
+#define cfoe_NS_coeff2_24_22_lsb 22
+#define xd_p_cfoe_lf_c1_4_0     0xA206
+#define cfoe_lf_c1_4_0_pos 3
+#define cfoe_lf_c1_4_0_len 5
+#define cfoe_lf_c1_4_0_lsb 0
+#define xd_p_cfoe_lf_c1_12_5    0xA207
+#define cfoe_lf_c1_12_5_pos 0
+#define cfoe_lf_c1_12_5_len 8
+#define cfoe_lf_c1_12_5_lsb 5
+#define xd_p_cfoe_lf_c1_20_13   0xA208
+#define cfoe_lf_c1_20_13_pos 0
+#define cfoe_lf_c1_20_13_len 8
+#define cfoe_lf_c1_20_13_lsb 13
+#define xd_p_cfoe_lf_c1_25_21   0xA209
+#define cfoe_lf_c1_25_21_pos 0
+#define cfoe_lf_c1_25_21_len 5
+#define cfoe_lf_c1_25_21_lsb 21
+#define xd_p_cfoe_lf_c2_2_0     0xA209
+#define cfoe_lf_c2_2_0_pos 5
+#define cfoe_lf_c2_2_0_len 3
+#define cfoe_lf_c2_2_0_lsb 0
+#define xd_p_cfoe_lf_c2_10_3    0xA20A
+#define cfoe_lf_c2_10_3_pos 0
+#define cfoe_lf_c2_10_3_len 8
+#define cfoe_lf_c2_10_3_lsb 3
+#define xd_p_cfoe_lf_c2_18_11   0xA20B
+#define cfoe_lf_c2_18_11_pos 0
+#define cfoe_lf_c2_18_11_len 8
+#define cfoe_lf_c2_18_11_lsb 11
+#define xd_p_cfoe_lf_c2_25_19   0xA20C
+#define cfoe_lf_c2_25_19_pos 0
+#define cfoe_lf_c2_25_19_len 7
+#define cfoe_lf_c2_25_19_lsb 19
+#define xd_p_cfoe_ifod_7_0      0xA20D
+#define cfoe_ifod_7_0_pos 0
+#define cfoe_ifod_7_0_len 8
+#define cfoe_ifod_7_0_lsb 0
+#define xd_p_cfoe_ifod_10_8     0xA20E
+#define cfoe_ifod_10_8_pos 0
+#define cfoe_ifod_10_8_len 3
+#define cfoe_ifod_10_8_lsb 8
+#define xd_p_cfoe_Divg_ctr_th   0xA20E
+#define cfoe_Divg_ctr_th_pos 4
+#define cfoe_Divg_ctr_th_len 4
+#define cfoe_Divg_ctr_th_lsb 0
+#define xd_p_cfoe_FOT_divg_th   0xA20F
+#define cfoe_FOT_divg_th_pos 0
+#define cfoe_FOT_divg_th_len 8
+#define cfoe_FOT_divg_th_lsb 0
+#define xd_p_cfoe_FOT_cnvg_th   0xA210
+#define cfoe_FOT_cnvg_th_pos 0
+#define cfoe_FOT_cnvg_th_len 8
+#define cfoe_FOT_cnvg_th_lsb 0
+#define xd_p_reg_cfoe_offset_7_0        0xA211
+#define reg_cfoe_offset_7_0_pos 0
+#define reg_cfoe_offset_7_0_len 8
+#define reg_cfoe_offset_7_0_lsb 0
+#define xd_p_reg_cfoe_offset_9_8        0xA212
+#define reg_cfoe_offset_9_8_pos 0
+#define reg_cfoe_offset_9_8_len 2
+#define reg_cfoe_offset_9_8_lsb 8
+#define xd_p_reg_cfoe_ifoe_sign_corr    0xA212
+#define reg_cfoe_ifoe_sign_corr_pos 2
+#define reg_cfoe_ifoe_sign_corr_len 1
+#define reg_cfoe_ifoe_sign_corr_lsb 0
+#define xd_r_cfoe_fot_LF_output_7_0     0xA218
+#define cfoe_fot_LF_output_7_0_pos 0
+#define cfoe_fot_LF_output_7_0_len 8
+#define cfoe_fot_LF_output_7_0_lsb 0
+#define xd_r_cfoe_fot_LF_output_15_8    0xA219
+#define cfoe_fot_LF_output_15_8_pos 0
+#define cfoe_fot_LF_output_15_8_len 8
+#define cfoe_fot_LF_output_15_8_lsb 8
+#define xd_r_cfoe_ifo_metric_7_0        0xA21A
+#define cfoe_ifo_metric_7_0_pos 0
+#define cfoe_ifo_metric_7_0_len 8
+#define cfoe_ifo_metric_7_0_lsb 0
+#define xd_r_cfoe_ifo_metric_15_8       0xA21B
+#define cfoe_ifo_metric_15_8_pos 0
+#define cfoe_ifo_metric_15_8_len 8
+#define cfoe_ifo_metric_15_8_lsb 8
+#define xd_r_cfoe_ifo_metric_23_16      0xA21C
+#define cfoe_ifo_metric_23_16_pos 0
+#define cfoe_ifo_metric_23_16_len 8
+#define cfoe_ifo_metric_23_16_lsb 16
+#define xd_p_ste_Nu     0xA220
+#define ste_Nu_pos 0
+#define ste_Nu_len 2
+#define ste_Nu_lsb 0
+#define xd_p_ste_GI     0xA220
+#define ste_GI_pos 2
+#define ste_GI_len 3
+#define ste_GI_lsb 0
+#define xd_p_ste_symbol_num     0xA221
+#define ste_symbol_num_pos 0
+#define ste_symbol_num_len 2
+#define ste_symbol_num_lsb 0
+#define xd_p_ste_sample_num     0xA221
+#define ste_sample_num_pos 2
+#define ste_sample_num_len 2
+#define ste_sample_num_lsb 0
+#define xd_p_reg_ste_buf_en     0xA221
+#define reg_ste_buf_en_pos 7
+#define reg_ste_buf_en_len 1
+#define reg_ste_buf_en_lsb 0
+#define xd_p_ste_FFT_offset_7_0 0xA222
+#define ste_FFT_offset_7_0_pos 0
+#define ste_FFT_offset_7_0_len 8
+#define ste_FFT_offset_7_0_lsb 0
+#define xd_p_ste_FFT_offset_11_8        0xA223
+#define ste_FFT_offset_11_8_pos 0
+#define ste_FFT_offset_11_8_len 4
+#define ste_FFT_offset_11_8_lsb 8
+#define xd_p_reg_ste_tstmod     0xA223
+#define reg_ste_tstmod_pos 5
+#define reg_ste_tstmod_len 1
+#define reg_ste_tstmod_lsb 0
+#define xd_p_ste_adv_start_7_0  0xA224
+#define ste_adv_start_7_0_pos 0
+#define ste_adv_start_7_0_len 8
+#define ste_adv_start_7_0_lsb 0
+#define xd_p_ste_adv_start_10_8 0xA225
+#define ste_adv_start_10_8_pos 0
+#define ste_adv_start_10_8_len 3
+#define ste_adv_start_10_8_lsb 8
+#define xd_p_ste_adv_stop       0xA226
+#define ste_adv_stop_pos 0
+#define ste_adv_stop_len 8
+#define ste_adv_stop_lsb 0
+#define xd_r_ste_P_value_7_0    0xA228
+#define ste_P_value_7_0_pos 0
+#define ste_P_value_7_0_len 8
+#define ste_P_value_7_0_lsb 0
+#define xd_r_ste_P_value_10_8   0xA229
+#define ste_P_value_10_8_pos 0
+#define ste_P_value_10_8_len 3
+#define ste_P_value_10_8_lsb 8
+#define xd_r_ste_M_value_7_0    0xA22A
+#define ste_M_value_7_0_pos 0
+#define ste_M_value_7_0_len 8
+#define ste_M_value_7_0_lsb 0
+#define xd_r_ste_M_value_10_8   0xA22B
+#define ste_M_value_10_8_pos 0
+#define ste_M_value_10_8_len 3
+#define ste_M_value_10_8_lsb 8
+#define xd_r_ste_H1     0xA22C
+#define ste_H1_pos 0
+#define ste_H1_len 7
+#define ste_H1_lsb 0
+#define xd_r_ste_H2     0xA22D
+#define ste_H2_pos 0
+#define ste_H2_len 7
+#define ste_H2_lsb 0
+#define xd_r_ste_H3     0xA22E
+#define ste_H3_pos 0
+#define ste_H3_len 7
+#define ste_H3_lsb 0
+#define xd_r_ste_H4     0xA22F
+#define ste_H4_pos 0
+#define ste_H4_len 7
+#define ste_H4_lsb 0
+#define xd_r_ste_Corr_value_I_7_0       0xA230
+#define ste_Corr_value_I_7_0_pos 0
+#define ste_Corr_value_I_7_0_len 8
+#define ste_Corr_value_I_7_0_lsb 0
+#define xd_r_ste_Corr_value_I_15_8      0xA231
+#define ste_Corr_value_I_15_8_pos 0
+#define ste_Corr_value_I_15_8_len 8
+#define ste_Corr_value_I_15_8_lsb 8
+#define xd_r_ste_Corr_value_I_23_16     0xA232
+#define ste_Corr_value_I_23_16_pos 0
+#define ste_Corr_value_I_23_16_len 8
+#define ste_Corr_value_I_23_16_lsb 16
+#define xd_r_ste_Corr_value_I_27_24     0xA233
+#define ste_Corr_value_I_27_24_pos 0
+#define ste_Corr_value_I_27_24_len 4
+#define ste_Corr_value_I_27_24_lsb 24
+#define xd_r_ste_Corr_value_Q_7_0       0xA234
+#define ste_Corr_value_Q_7_0_pos 0
+#define ste_Corr_value_Q_7_0_len 8
+#define ste_Corr_value_Q_7_0_lsb 0
+#define xd_r_ste_Corr_value_Q_15_8      0xA235
+#define ste_Corr_value_Q_15_8_pos 0
+#define ste_Corr_value_Q_15_8_len 8
+#define ste_Corr_value_Q_15_8_lsb 8
+#define xd_r_ste_Corr_value_Q_23_16     0xA236
+#define ste_Corr_value_Q_23_16_pos 0
+#define ste_Corr_value_Q_23_16_len 8
+#define ste_Corr_value_Q_23_16_lsb 16
+#define xd_r_ste_Corr_value_Q_27_24     0xA237
+#define ste_Corr_value_Q_27_24_pos 0
+#define ste_Corr_value_Q_27_24_len 4
+#define ste_Corr_value_Q_27_24_lsb 24
+#define xd_r_ste_J_num_7_0      0xA238
+#define ste_J_num_7_0_pos 0
+#define ste_J_num_7_0_len 8
+#define ste_J_num_7_0_lsb 0
+#define xd_r_ste_J_num_15_8     0xA239
+#define ste_J_num_15_8_pos 0
+#define ste_J_num_15_8_len 8
+#define ste_J_num_15_8_lsb 8
+#define xd_r_ste_J_num_23_16    0xA23A
+#define ste_J_num_23_16_pos 0
+#define ste_J_num_23_16_len 8
+#define ste_J_num_23_16_lsb 16
+#define xd_r_ste_J_num_31_24    0xA23B
+#define ste_J_num_31_24_pos 0
+#define ste_J_num_31_24_len 8
+#define ste_J_num_31_24_lsb 24
+#define xd_r_ste_J_den_7_0      0xA23C
+#define ste_J_den_7_0_pos 0
+#define ste_J_den_7_0_len 8
+#define ste_J_den_7_0_lsb 0
+#define xd_r_ste_J_den_15_8     0xA23D
+#define ste_J_den_15_8_pos 0
+#define ste_J_den_15_8_len 8
+#define ste_J_den_15_8_lsb 8
+#define xd_r_ste_J_den_18_16    0xA23E
+#define ste_J_den_18_16_pos 0
+#define ste_J_den_18_16_len 3
+#define ste_J_den_18_16_lsb 16
+#define xd_r_ste_Beacon_Indicator       0xA23E
+#define ste_Beacon_Indicator_pos 4
+#define ste_Beacon_Indicator_len 1
+#define ste_Beacon_Indicator_lsb 0
+#define xd_r_tpsd_Frame_Num     0xA250
+#define tpsd_Frame_Num_pos 0
+#define tpsd_Frame_Num_len 2
+#define tpsd_Frame_Num_lsb 0
+#define xd_r_tpsd_Constel       0xA250
+#define tpsd_Constel_pos 2
+#define tpsd_Constel_len 2
+#define tpsd_Constel_lsb 0
+#define xd_r_tpsd_GI    0xA250
+#define tpsd_GI_pos 4
+#define tpsd_GI_len 2
+#define tpsd_GI_lsb 0
+#define xd_r_tpsd_Mode  0xA250
+#define tpsd_Mode_pos 6
+#define tpsd_Mode_len 2
+#define tpsd_Mode_lsb 0
+#define xd_r_tpsd_CR_HP 0xA251
+#define tpsd_CR_HP_pos 0
+#define tpsd_CR_HP_len 3
+#define tpsd_CR_HP_lsb 0
+#define xd_r_tpsd_CR_LP 0xA251
+#define tpsd_CR_LP_pos 3
+#define tpsd_CR_LP_len 3
+#define tpsd_CR_LP_lsb 0
+#define xd_r_tpsd_Hie   0xA252
+#define tpsd_Hie_pos 0
+#define tpsd_Hie_len 3
+#define tpsd_Hie_lsb 0
+#define xd_r_tpsd_Res_Bits      0xA252
+#define tpsd_Res_Bits_pos 3
+#define tpsd_Res_Bits_len 5
+#define tpsd_Res_Bits_lsb 0
+#define xd_r_tpsd_Res_Bits_0    0xA253
+#define tpsd_Res_Bits_0_pos 0
+#define tpsd_Res_Bits_0_len 1
+#define tpsd_Res_Bits_0_lsb 0
+#define xd_r_tpsd_LengthInd     0xA253
+#define tpsd_LengthInd_pos 1
+#define tpsd_LengthInd_len 6
+#define tpsd_LengthInd_lsb 0
+#define xd_r_tpsd_Cell_Id_7_0   0xA254
+#define tpsd_Cell_Id_7_0_pos 0
+#define tpsd_Cell_Id_7_0_len 8
+#define tpsd_Cell_Id_7_0_lsb 0
+#define xd_r_tpsd_Cell_Id_15_8  0xA255
+#define tpsd_Cell_Id_15_8_pos 0
+#define tpsd_Cell_Id_15_8_len 8
+#define tpsd_Cell_Id_15_8_lsb 0
+#define xd_p_reg_fft_mask_tone0_7_0     0xA260
+#define reg_fft_mask_tone0_7_0_pos 0
+#define reg_fft_mask_tone0_7_0_len 8
+#define reg_fft_mask_tone0_7_0_lsb 0
+#define xd_p_reg_fft_mask_tone0_12_8    0xA261
+#define reg_fft_mask_tone0_12_8_pos 0
+#define reg_fft_mask_tone0_12_8_len 5
+#define reg_fft_mask_tone0_12_8_lsb 8
+#define xd_p_reg_fft_mask_tone1_7_0     0xA262
+#define reg_fft_mask_tone1_7_0_pos 0
+#define reg_fft_mask_tone1_7_0_len 8
+#define reg_fft_mask_tone1_7_0_lsb 0
+#define xd_p_reg_fft_mask_tone1_12_8    0xA263
+#define reg_fft_mask_tone1_12_8_pos 0
+#define reg_fft_mask_tone1_12_8_len 5
+#define reg_fft_mask_tone1_12_8_lsb 8
+#define xd_p_reg_fft_mask_tone2_7_0     0xA264
+#define reg_fft_mask_tone2_7_0_pos 0
+#define reg_fft_mask_tone2_7_0_len 8
+#define reg_fft_mask_tone2_7_0_lsb 0
+#define xd_p_reg_fft_mask_tone2_12_8    0xA265
+#define reg_fft_mask_tone2_12_8_pos 0
+#define reg_fft_mask_tone2_12_8_len 5
+#define reg_fft_mask_tone2_12_8_lsb 8
+#define xd_p_reg_fft_mask_tone3_7_0     0xA266
+#define reg_fft_mask_tone3_7_0_pos 0
+#define reg_fft_mask_tone3_7_0_len 8
+#define reg_fft_mask_tone3_7_0_lsb 0
+#define xd_p_reg_fft_mask_tone3_12_8    0xA267
+#define reg_fft_mask_tone3_12_8_pos 0
+#define reg_fft_mask_tone3_12_8_len 5
+#define reg_fft_mask_tone3_12_8_lsb 8
+#define xd_p_reg_fft_mask_from0_7_0     0xA268
+#define reg_fft_mask_from0_7_0_pos 0
+#define reg_fft_mask_from0_7_0_len 8
+#define reg_fft_mask_from0_7_0_lsb 0
+#define xd_p_reg_fft_mask_from0_12_8    0xA269
+#define reg_fft_mask_from0_12_8_pos 0
+#define reg_fft_mask_from0_12_8_len 5
+#define reg_fft_mask_from0_12_8_lsb 8
+#define xd_p_reg_fft_mask_to0_7_0       0xA26A
+#define reg_fft_mask_to0_7_0_pos 0
+#define reg_fft_mask_to0_7_0_len 8
+#define reg_fft_mask_to0_7_0_lsb 0
+#define xd_p_reg_fft_mask_to0_12_8      0xA26B
+#define reg_fft_mask_to0_12_8_pos 0
+#define reg_fft_mask_to0_12_8_len 5
+#define reg_fft_mask_to0_12_8_lsb 8
+#define xd_p_reg_fft_mask_from1_7_0     0xA26C
+#define reg_fft_mask_from1_7_0_pos 0
+#define reg_fft_mask_from1_7_0_len 8
+#define reg_fft_mask_from1_7_0_lsb 0
+#define xd_p_reg_fft_mask_from1_12_8    0xA26D
+#define reg_fft_mask_from1_12_8_pos 0
+#define reg_fft_mask_from1_12_8_len 5
+#define reg_fft_mask_from1_12_8_lsb 8
+#define xd_p_reg_fft_mask_to1_7_0       0xA26E
+#define reg_fft_mask_to1_7_0_pos 0
+#define reg_fft_mask_to1_7_0_len 8
+#define reg_fft_mask_to1_7_0_lsb 0
+#define xd_p_reg_fft_mask_to1_12_8      0xA26F
+#define reg_fft_mask_to1_12_8_pos 0
+#define reg_fft_mask_to1_12_8_len 5
+#define reg_fft_mask_to1_12_8_lsb 8
+#define xd_p_reg_cge_idx0_7_0   0xA280
+#define reg_cge_idx0_7_0_pos 0
+#define reg_cge_idx0_7_0_len 8
+#define reg_cge_idx0_7_0_lsb 0
+#define xd_p_reg_cge_idx0_12_8  0xA281
+#define reg_cge_idx0_12_8_pos 0
+#define reg_cge_idx0_12_8_len 5
+#define reg_cge_idx0_12_8_lsb 8
+#define xd_p_reg_cge_idx1_7_0   0xA282
+#define reg_cge_idx1_7_0_pos 0
+#define reg_cge_idx1_7_0_len 8
+#define reg_cge_idx1_7_0_lsb 0
+#define xd_p_reg_cge_idx1_12_8  0xA283
+#define reg_cge_idx1_12_8_pos 0
+#define reg_cge_idx1_12_8_len 5
+#define reg_cge_idx1_12_8_lsb 8
+#define xd_p_reg_cge_idx2_7_0   0xA284
+#define reg_cge_idx2_7_0_pos 0
+#define reg_cge_idx2_7_0_len 8
+#define reg_cge_idx2_7_0_lsb 0
+#define xd_p_reg_cge_idx2_12_8  0xA285
+#define reg_cge_idx2_12_8_pos 0
+#define reg_cge_idx2_12_8_len 5
+#define reg_cge_idx2_12_8_lsb 8
+#define xd_p_reg_cge_idx3_7_0   0xA286
+#define reg_cge_idx3_7_0_pos 0
+#define reg_cge_idx3_7_0_len 8
+#define reg_cge_idx3_7_0_lsb 0
+#define xd_p_reg_cge_idx3_12_8  0xA287
+#define reg_cge_idx3_12_8_pos 0
+#define reg_cge_idx3_12_8_len 5
+#define reg_cge_idx3_12_8_lsb 8
+#define xd_p_reg_cge_idx4_7_0   0xA288
+#define reg_cge_idx4_7_0_pos 0
+#define reg_cge_idx4_7_0_len 8
+#define reg_cge_idx4_7_0_lsb 0
+#define xd_p_reg_cge_idx4_12_8  0xA289
+#define reg_cge_idx4_12_8_pos 0
+#define reg_cge_idx4_12_8_len 5
+#define reg_cge_idx4_12_8_lsb 8
+#define xd_p_reg_cge_idx5_7_0   0xA28A
+#define reg_cge_idx5_7_0_pos 0
+#define reg_cge_idx5_7_0_len 8
+#define reg_cge_idx5_7_0_lsb 0
+#define xd_p_reg_cge_idx5_12_8  0xA28B
+#define reg_cge_idx5_12_8_pos 0
+#define reg_cge_idx5_12_8_len 5
+#define reg_cge_idx5_12_8_lsb 8
+#define xd_p_reg_cge_idx6_7_0   0xA28C
+#define reg_cge_idx6_7_0_pos 0
+#define reg_cge_idx6_7_0_len 8
+#define reg_cge_idx6_7_0_lsb 0
+#define xd_p_reg_cge_idx6_12_8  0xA28D
+#define reg_cge_idx6_12_8_pos 0
+#define reg_cge_idx6_12_8_len 5
+#define reg_cge_idx6_12_8_lsb 8
+#define xd_p_reg_cge_idx7_7_0   0xA28E
+#define reg_cge_idx7_7_0_pos 0
+#define reg_cge_idx7_7_0_len 8
+#define reg_cge_idx7_7_0_lsb 0
+#define xd_p_reg_cge_idx7_12_8  0xA28F
+#define reg_cge_idx7_12_8_pos 0
+#define reg_cge_idx7_12_8_len 5
+#define reg_cge_idx7_12_8_lsb 8
+#define xd_p_reg_cge_idx8_7_0   0xA290
+#define reg_cge_idx8_7_0_pos 0
+#define reg_cge_idx8_7_0_len 8
+#define reg_cge_idx8_7_0_lsb 0
+#define xd_p_reg_cge_idx8_12_8  0xA291
+#define reg_cge_idx8_12_8_pos 0
+#define reg_cge_idx8_12_8_len 5
+#define reg_cge_idx8_12_8_lsb 8
+#define xd_p_reg_cge_idx9_7_0   0xA292
+#define reg_cge_idx9_7_0_pos 0
+#define reg_cge_idx9_7_0_len 8
+#define reg_cge_idx9_7_0_lsb 0
+#define xd_p_reg_cge_idx9_12_8  0xA293
+#define reg_cge_idx9_12_8_pos 0
+#define reg_cge_idx9_12_8_len 5
+#define reg_cge_idx9_12_8_lsb 8
+#define xd_p_reg_cge_idx10_7_0  0xA294
+#define reg_cge_idx10_7_0_pos 0
+#define reg_cge_idx10_7_0_len 8
+#define reg_cge_idx10_7_0_lsb 0
+#define xd_p_reg_cge_idx10_12_8 0xA295
+#define reg_cge_idx10_12_8_pos 0
+#define reg_cge_idx10_12_8_len 5
+#define reg_cge_idx10_12_8_lsb 8
+#define xd_p_reg_cge_idx11_7_0  0xA296
+#define reg_cge_idx11_7_0_pos 0
+#define reg_cge_idx11_7_0_len 8
+#define reg_cge_idx11_7_0_lsb 0
+#define xd_p_reg_cge_idx11_12_8 0xA297
+#define reg_cge_idx11_12_8_pos 0
+#define reg_cge_idx11_12_8_len 5
+#define reg_cge_idx11_12_8_lsb 8
+#define xd_p_reg_cge_idx12_7_0  0xA298
+#define reg_cge_idx12_7_0_pos 0
+#define reg_cge_idx12_7_0_len 8
+#define reg_cge_idx12_7_0_lsb 0
+#define xd_p_reg_cge_idx12_12_8 0xA299
+#define reg_cge_idx12_12_8_pos 0
+#define reg_cge_idx12_12_8_len 5
+#define reg_cge_idx12_12_8_lsb 8
+#define xd_p_reg_cge_idx13_7_0  0xA29A
+#define reg_cge_idx13_7_0_pos 0
+#define reg_cge_idx13_7_0_len 8
+#define reg_cge_idx13_7_0_lsb 0
+#define xd_p_reg_cge_idx13_12_8 0xA29B
+#define reg_cge_idx13_12_8_pos 0
+#define reg_cge_idx13_12_8_len 5
+#define reg_cge_idx13_12_8_lsb 8
+#define xd_p_reg_cge_idx14_7_0  0xA29C
+#define reg_cge_idx14_7_0_pos 0
+#define reg_cge_idx14_7_0_len 8
+#define reg_cge_idx14_7_0_lsb 0
+#define xd_p_reg_cge_idx14_12_8 0xA29D
+#define reg_cge_idx14_12_8_pos 0
+#define reg_cge_idx14_12_8_len 5
+#define reg_cge_idx14_12_8_lsb 8
+#define xd_p_reg_cge_idx15_7_0  0xA29E
+#define reg_cge_idx15_7_0_pos 0
+#define reg_cge_idx15_7_0_len 8
+#define reg_cge_idx15_7_0_lsb 0
+#define xd_p_reg_cge_idx15_12_8 0xA29F
+#define reg_cge_idx15_12_8_pos 0
+#define reg_cge_idx15_12_8_len 5
+#define reg_cge_idx15_12_8_lsb 8
+#define xd_r_reg_fft_crc        0xA2A8
+#define reg_fft_crc_pos 0
+#define reg_fft_crc_len 8
+#define reg_fft_crc_lsb 0
+#define xd_p_fd_fft_shift_max   0xA2A9
+#define fd_fft_shift_max_pos 0
+#define fd_fft_shift_max_len 4
+#define fd_fft_shift_max_lsb 0
+#define xd_r_fd_fft_shift       0xA2A9
+#define fd_fft_shift_pos 4
+#define fd_fft_shift_len 4
+#define fd_fft_shift_lsb 0
+#define xd_r_fd_fft_frame_num   0xA2AA
+#define fd_fft_frame_num_pos 0
+#define fd_fft_frame_num_len 2
+#define fd_fft_frame_num_lsb 0
+#define xd_r_fd_fft_symbol_count        0xA2AB
+#define fd_fft_symbol_count_pos 0
+#define fd_fft_symbol_count_len 7
+#define fd_fft_symbol_count_lsb 0
+#define xd_r_reg_fft_idx_max_7_0        0xA2AC
+#define reg_fft_idx_max_7_0_pos 0
+#define reg_fft_idx_max_7_0_len 8
+#define reg_fft_idx_max_7_0_lsb 0
+#define xd_r_reg_fft_idx_max_12_8       0xA2AD
+#define reg_fft_idx_max_12_8_pos 0
+#define reg_fft_idx_max_12_8_len 5
+#define reg_fft_idx_max_12_8_lsb 8
+#define xd_p_reg_cge_program    0xA2AE
+#define reg_cge_program_pos 0
+#define reg_cge_program_len 1
+#define reg_cge_program_lsb 0
+#define xd_p_reg_cge_fixed      0xA2AE
+#define reg_cge_fixed_pos 1
+#define reg_cge_fixed_len 1
+#define reg_cge_fixed_lsb 0
+#define xd_p_reg_fft_rotate_en  0xA2AE
+#define reg_fft_rotate_en_pos 2
+#define reg_fft_rotate_en_len 1
+#define reg_fft_rotate_en_lsb 0
+#define xd_p_reg_fft_rotate_base_4_0    0xA2AE
+#define reg_fft_rotate_base_4_0_pos 3
+#define reg_fft_rotate_base_4_0_len 5
+#define reg_fft_rotate_base_4_0_lsb 0
+#define xd_p_reg_fft_rotate_base_12_5   0xA2AF
+#define reg_fft_rotate_base_12_5_pos 0
+#define reg_fft_rotate_base_12_5_len 8
+#define reg_fft_rotate_base_12_5_lsb 5
+#define xd_p_reg_gp_trigger_fd  0xA2B8
+#define reg_gp_trigger_fd_pos 0
+#define reg_gp_trigger_fd_len 1
+#define reg_gp_trigger_fd_lsb 0
+#define xd_p_reg_trigger_sel_fd 0xA2B8
+#define reg_trigger_sel_fd_pos 1
+#define reg_trigger_sel_fd_len 2
+#define reg_trigger_sel_fd_lsb 0
+#define xd_p_reg_trigger_module_sel_fd  0xA2B9
+#define reg_trigger_module_sel_fd_pos 0
+#define reg_trigger_module_sel_fd_len 6
+#define reg_trigger_module_sel_fd_lsb 0
+#define xd_p_reg_trigger_set_sel_fd     0xA2BA
+#define reg_trigger_set_sel_fd_pos 0
+#define reg_trigger_set_sel_fd_len 6
+#define reg_trigger_set_sel_fd_lsb 0
+#define xd_p_reg_fd_noname_7_0  0xA2BC
+#define reg_fd_noname_7_0_pos 0
+#define reg_fd_noname_7_0_len 8
+#define reg_fd_noname_7_0_lsb 0
+#define xd_p_reg_fd_noname_15_8 0xA2BD
+#define reg_fd_noname_15_8_pos 0
+#define reg_fd_noname_15_8_len 8
+#define reg_fd_noname_15_8_lsb 8
+#define xd_p_reg_fd_noname_23_16        0xA2BE
+#define reg_fd_noname_23_16_pos 0
+#define reg_fd_noname_23_16_len 8
+#define reg_fd_noname_23_16_lsb 16
+#define xd_p_reg_fd_noname_31_24        0xA2BF
+#define reg_fd_noname_31_24_pos 0
+#define reg_fd_noname_31_24_len 8
+#define reg_fd_noname_31_24_lsb 24
+#define xd_r_fd_fpcc_cp_corr_signn      0xA2C0
+#define fd_fpcc_cp_corr_signn_pos 0
+#define fd_fpcc_cp_corr_signn_len 8
+#define fd_fpcc_cp_corr_signn_lsb 0
+#define xd_p_reg_feq_s1 0xA2C1
+#define reg_feq_s1_pos 0
+#define reg_feq_s1_len 5
+#define reg_feq_s1_lsb 0
+#define xd_p_fd_fpcc_cp_corr_tone_th    0xA2C2
+#define fd_fpcc_cp_corr_tone_th_pos 0
+#define fd_fpcc_cp_corr_tone_th_len 6
+#define fd_fpcc_cp_corr_tone_th_lsb 0
+#define xd_p_fd_fpcc_cp_corr_symbol_log_th      0xA2C3
+#define fd_fpcc_cp_corr_symbol_log_th_pos 0
+#define fd_fpcc_cp_corr_symbol_log_th_len 4
+#define fd_fpcc_cp_corr_symbol_log_th_lsb 0
+#define xd_p_fd_fpcc_cp_corr_int        0xA2C4
+#define fd_fpcc_cp_corr_int_pos 0
+#define fd_fpcc_cp_corr_int_len 1
+#define fd_fpcc_cp_corr_int_lsb 0
+#define xd_p_reg_sfoe_ns_7_0    0xA320
+#define reg_sfoe_ns_7_0_pos 0
+#define reg_sfoe_ns_7_0_len 8
+#define reg_sfoe_ns_7_0_lsb 0
+#define xd_p_reg_sfoe_ns_14_8   0xA321
+#define reg_sfoe_ns_14_8_pos 0
+#define reg_sfoe_ns_14_8_len 7
+#define reg_sfoe_ns_14_8_lsb 8
+#define xd_p_reg_sfoe_c1_7_0    0xA322
+#define reg_sfoe_c1_7_0_pos 0
+#define reg_sfoe_c1_7_0_len 8
+#define reg_sfoe_c1_7_0_lsb 0
+#define xd_p_reg_sfoe_c1_15_8   0xA323
+#define reg_sfoe_c1_15_8_pos 0
+#define reg_sfoe_c1_15_8_len 8
+#define reg_sfoe_c1_15_8_lsb 8
+#define xd_p_reg_sfoe_c1_17_16  0xA324
+#define reg_sfoe_c1_17_16_pos 0
+#define reg_sfoe_c1_17_16_len 2
+#define reg_sfoe_c1_17_16_lsb 16
+#define xd_p_reg_sfoe_c2_7_0    0xA325
+#define reg_sfoe_c2_7_0_pos 0
+#define reg_sfoe_c2_7_0_len 8
+#define reg_sfoe_c2_7_0_lsb 0
+#define xd_p_reg_sfoe_c2_15_8   0xA326
+#define reg_sfoe_c2_15_8_pos 0
+#define reg_sfoe_c2_15_8_len 8
+#define reg_sfoe_c2_15_8_lsb 8
+#define xd_p_reg_sfoe_c2_17_16  0xA327
+#define reg_sfoe_c2_17_16_pos 0
+#define reg_sfoe_c2_17_16_len 2
+#define reg_sfoe_c2_17_16_lsb 16
+#define xd_r_reg_sfoe_out_9_2   0xA328
+#define reg_sfoe_out_9_2_pos 0
+#define reg_sfoe_out_9_2_len 8
+#define reg_sfoe_out_9_2_lsb 0
+#define xd_r_reg_sfoe_out_1_0   0xA329
+#define reg_sfoe_out_1_0_pos 0
+#define reg_sfoe_out_1_0_len 2
+#define reg_sfoe_out_1_0_lsb 0
+#define xd_p_reg_sfoe_lm_counter_th     0xA32A
+#define reg_sfoe_lm_counter_th_pos 0
+#define reg_sfoe_lm_counter_th_len 4
+#define reg_sfoe_lm_counter_th_lsb 0
+#define xd_p_reg_sfoe_convg_th  0xA32B
+#define reg_sfoe_convg_th_pos 0
+#define reg_sfoe_convg_th_len 8
+#define reg_sfoe_convg_th_lsb 0
+#define xd_p_reg_sfoe_divg_th   0xA32C
+#define reg_sfoe_divg_th_pos 0
+#define reg_sfoe_divg_th_len 8
+#define reg_sfoe_divg_th_lsb 0
+#define xd_p_fd_tpsd_en 0xA330
+#define fd_tpsd_en_pos 0
+#define fd_tpsd_en_len 1
+#define fd_tpsd_en_lsb 0
+#define xd_p_fd_tpsd_dis        0xA330
+#define fd_tpsd_dis_pos 1
+#define fd_tpsd_dis_len 1
+#define fd_tpsd_dis_lsb 0
+#define xd_p_fd_tpsd_rst        0xA330
+#define fd_tpsd_rst_pos 2
+#define fd_tpsd_rst_len 1
+#define fd_tpsd_rst_lsb 0
+#define xd_p_fd_tpsd_lock       0xA330
+#define fd_tpsd_lock_pos 3
+#define fd_tpsd_lock_len 1
+#define fd_tpsd_lock_lsb 0
+#define xd_r_fd_tpsd_s19        0xA330
+#define fd_tpsd_s19_pos 4
+#define fd_tpsd_s19_len 1
+#define fd_tpsd_s19_lsb 0
+#define xd_r_fd_tpsd_s17        0xA330
+#define fd_tpsd_s17_pos 5
+#define fd_tpsd_s17_len 1
+#define fd_tpsd_s17_lsb 0
+#define xd_p_fd_sfr_ste_en      0xA331
+#define fd_sfr_ste_en_pos 0
+#define fd_sfr_ste_en_len 1
+#define fd_sfr_ste_en_lsb 0
+#define xd_p_fd_sfr_ste_dis     0xA331
+#define fd_sfr_ste_dis_pos 1
+#define fd_sfr_ste_dis_len 1
+#define fd_sfr_ste_dis_lsb 0
+#define xd_p_fd_sfr_ste_rst     0xA331
+#define fd_sfr_ste_rst_pos 2
+#define fd_sfr_ste_rst_len 1
+#define fd_sfr_ste_rst_lsb 0
+#define xd_p_fd_sfr_ste_mode    0xA331
+#define fd_sfr_ste_mode_pos 3
+#define fd_sfr_ste_mode_len 1
+#define fd_sfr_ste_mode_lsb 0
+#define xd_p_fd_sfr_ste_done    0xA331
+#define fd_sfr_ste_done_pos 4
+#define fd_sfr_ste_done_len 1
+#define fd_sfr_ste_done_lsb 0
+#define xd_p_reg_cfoe_ffoe_en   0xA332
+#define reg_cfoe_ffoe_en_pos 0
+#define reg_cfoe_ffoe_en_len 1
+#define reg_cfoe_ffoe_en_lsb 0
+#define xd_p_reg_cfoe_ffoe_dis  0xA332
+#define reg_cfoe_ffoe_dis_pos 1
+#define reg_cfoe_ffoe_dis_len 1
+#define reg_cfoe_ffoe_dis_lsb 0
+#define xd_p_reg_cfoe_ffoe_rst  0xA332
+#define reg_cfoe_ffoe_rst_pos 2
+#define reg_cfoe_ffoe_rst_len 1
+#define reg_cfoe_ffoe_rst_lsb 0
+#define xd_p_reg_cfoe_ifoe_en   0xA332
+#define reg_cfoe_ifoe_en_pos 3
+#define reg_cfoe_ifoe_en_len 1
+#define reg_cfoe_ifoe_en_lsb 0
+#define xd_p_reg_cfoe_ifoe_dis  0xA332
+#define reg_cfoe_ifoe_dis_pos 4
+#define reg_cfoe_ifoe_dis_len 1
+#define reg_cfoe_ifoe_dis_lsb 0
+#define xd_p_reg_cfoe_ifoe_rst  0xA332
+#define reg_cfoe_ifoe_rst_pos 5
+#define reg_cfoe_ifoe_rst_len 1
+#define reg_cfoe_ifoe_rst_lsb 0
+#define xd_p_reg_cfoe_fot_en    0xA332
+#define reg_cfoe_fot_en_pos 6
+#define reg_cfoe_fot_en_len 1
+#define reg_cfoe_fot_en_lsb 0
+#define xd_p_reg_cfoe_fot_lm_en 0xA332
+#define reg_cfoe_fot_lm_en_pos 7
+#define reg_cfoe_fot_lm_en_len 1
+#define reg_cfoe_fot_lm_en_lsb 0
+#define xd_p_reg_cfoe_fot_rst   0xA333
+#define reg_cfoe_fot_rst_pos 0
+#define reg_cfoe_fot_rst_len 1
+#define reg_cfoe_fot_rst_lsb 0
+#define xd_r_fd_cfoe_ffoe_done  0xA333
+#define fd_cfoe_ffoe_done_pos 1
+#define fd_cfoe_ffoe_done_len 1
+#define fd_cfoe_ffoe_done_lsb 0
+#define xd_p_fd_cfoe_metric_vld 0xA333
+#define fd_cfoe_metric_vld_pos 2
+#define fd_cfoe_metric_vld_len 1
+#define fd_cfoe_metric_vld_lsb 0
+#define xd_p_reg_cfoe_ifod_vld  0xA333
+#define reg_cfoe_ifod_vld_pos 3
+#define reg_cfoe_ifod_vld_len 1
+#define reg_cfoe_ifod_vld_lsb 0
+#define xd_r_fd_cfoe_ifoe_done  0xA333
+#define fd_cfoe_ifoe_done_pos 4
+#define fd_cfoe_ifoe_done_len 1
+#define fd_cfoe_ifoe_done_lsb 0
+#define xd_r_fd_cfoe_fot_valid  0xA333
+#define fd_cfoe_fot_valid_pos 5
+#define fd_cfoe_fot_valid_len 1
+#define fd_cfoe_fot_valid_lsb 0
+#define xd_p_reg_cfoe_divg_int  0xA333
+#define reg_cfoe_divg_int_pos 6
+#define reg_cfoe_divg_int_len 1
+#define reg_cfoe_divg_int_lsb 0
+#define xd_r_reg_cfoe_divg_flag 0xA333
+#define reg_cfoe_divg_flag_pos 7
+#define reg_cfoe_divg_flag_len 1
+#define reg_cfoe_divg_flag_lsb 0
+#define xd_p_reg_sfoe_en        0xA334
+#define reg_sfoe_en_pos 0
+#define reg_sfoe_en_len 1
+#define reg_sfoe_en_lsb 0
+#define xd_p_reg_sfoe_dis       0xA334
+#define reg_sfoe_dis_pos 1
+#define reg_sfoe_dis_len 1
+#define reg_sfoe_dis_lsb 0
+#define xd_p_reg_sfoe_rst       0xA334
+#define reg_sfoe_rst_pos 2
+#define reg_sfoe_rst_len 1
+#define reg_sfoe_rst_lsb 0
+#define xd_p_reg_sfoe_vld_int   0xA334
+#define reg_sfoe_vld_int_pos 3
+#define reg_sfoe_vld_int_len 1
+#define reg_sfoe_vld_int_lsb 0
+#define xd_p_reg_sfoe_lm_en     0xA334
+#define reg_sfoe_lm_en_pos 4
+#define reg_sfoe_lm_en_len 1
+#define reg_sfoe_lm_en_lsb 0
+#define xd_p_reg_sfoe_divg_int  0xA334
+#define reg_sfoe_divg_int_pos 5
+#define reg_sfoe_divg_int_len 1
+#define reg_sfoe_divg_int_lsb 0
+#define xd_r_reg_sfoe_divg_flag 0xA334
+#define reg_sfoe_divg_flag_pos 6
+#define reg_sfoe_divg_flag_len 1
+#define reg_sfoe_divg_flag_lsb 0
+#define xd_p_reg_fft_rst        0xA335
+#define reg_fft_rst_pos 0
+#define reg_fft_rst_len 1
+#define reg_fft_rst_lsb 0
+#define xd_p_reg_fft_fast_beacon        0xA335
+#define reg_fft_fast_beacon_pos 1
+#define reg_fft_fast_beacon_len 1
+#define reg_fft_fast_beacon_lsb 0
+#define xd_p_reg_fft_fast_valid 0xA335
+#define reg_fft_fast_valid_pos 2
+#define reg_fft_fast_valid_len 1
+#define reg_fft_fast_valid_lsb 0
+#define xd_p_reg_fft_mask_en    0xA335
+#define reg_fft_mask_en_pos 3
+#define reg_fft_mask_en_len 1
+#define reg_fft_mask_en_lsb 0
+#define xd_p_reg_fft_crc_en     0xA335
+#define reg_fft_crc_en_pos 4
+#define reg_fft_crc_en_len 1
+#define reg_fft_crc_en_lsb 0
+#define xd_p_reg_finr_en        0xA336
+#define reg_finr_en_pos 0
+#define reg_finr_en_len 1
+#define reg_finr_en_lsb 0
+#define xd_p_fd_fste_en 0xA337
+#define fd_fste_en_pos 1
+#define fd_fste_en_len 1
+#define fd_fste_en_lsb 0
+#define xd_p_fd_sqi_tps_level_shift     0xA338
+#define fd_sqi_tps_level_shift_pos 0
+#define fd_sqi_tps_level_shift_len 8
+#define fd_sqi_tps_level_shift_lsb 0
+#define xd_p_fd_pilot_ma_len    0xA339
+#define fd_pilot_ma_len_pos 0
+#define fd_pilot_ma_len_len 6
+#define fd_pilot_ma_len_lsb 0
+#define xd_p_fd_tps_ma_len      0xA33A
+#define fd_tps_ma_len_pos 0
+#define fd_tps_ma_len_len 6
+#define fd_tps_ma_len_lsb 0
+#define xd_p_fd_sqi_s3  0xA33B
+#define fd_sqi_s3_pos 0
+#define fd_sqi_s3_len 8
+#define fd_sqi_s3_lsb 0
+#define xd_p_fd_sqi_dummy_reg_0 0xA33C
+#define fd_sqi_dummy_reg_0_pos 0
+#define fd_sqi_dummy_reg_0_len 1
+#define fd_sqi_dummy_reg_0_lsb 0
+#define xd_p_fd_sqi_debug_sel   0xA33C
+#define fd_sqi_debug_sel_pos 1
+#define fd_sqi_debug_sel_len 2
+#define fd_sqi_debug_sel_lsb 0
+#define xd_p_fd_sqi_s2  0xA33C
+#define fd_sqi_s2_pos 3
+#define fd_sqi_s2_len 5
+#define fd_sqi_s2_lsb 0
+#define xd_p_fd_sqi_dummy_reg_1 0xA33D
+#define fd_sqi_dummy_reg_1_pos 0
+#define fd_sqi_dummy_reg_1_len 1
+#define fd_sqi_dummy_reg_1_lsb 0
+#define xd_p_fd_inr_ignore      0xA33D
+#define fd_inr_ignore_pos 1
+#define fd_inr_ignore_len 1
+#define fd_inr_ignore_lsb 0
+#define xd_p_fd_pilot_ignore    0xA33D
+#define fd_pilot_ignore_pos 2
+#define fd_pilot_ignore_len 1
+#define fd_pilot_ignore_lsb 0
+#define xd_p_fd_etps_ignore     0xA33D
+#define fd_etps_ignore_pos 3
+#define fd_etps_ignore_len 1
+#define fd_etps_ignore_lsb 0
+#define xd_p_fd_sqi_s1  0xA33D
+#define fd_sqi_s1_pos 4
+#define fd_sqi_s1_len 4
+#define fd_sqi_s1_lsb 0
+#define xd_p_reg_fste_ehw_7_0   0xA33E
+#define reg_fste_ehw_7_0_pos 0
+#define reg_fste_ehw_7_0_len 8
+#define reg_fste_ehw_7_0_lsb 0
+#define xd_p_reg_fste_ehw_9_8   0xA33F
+#define reg_fste_ehw_9_8_pos 0
+#define reg_fste_ehw_9_8_len 2
+#define reg_fste_ehw_9_8_lsb 8
+#define xd_p_reg_fste_i_adj_vld 0xA33F
+#define reg_fste_i_adj_vld_pos 2
+#define reg_fste_i_adj_vld_len 1
+#define reg_fste_i_adj_vld_lsb 0
+#define xd_p_reg_fste_phase_ini_7_0     0xA340
+#define reg_fste_phase_ini_7_0_pos 0
+#define reg_fste_phase_ini_7_0_len 8
+#define reg_fste_phase_ini_7_0_lsb 0
+#define xd_p_reg_fste_phase_ini_11_8    0xA341
+#define reg_fste_phase_ini_11_8_pos 0
+#define reg_fste_phase_ini_11_8_len 4
+#define reg_fste_phase_ini_11_8_lsb 8
+#define xd_p_reg_fste_phase_inc_3_0     0xA341
+#define reg_fste_phase_inc_3_0_pos 4
+#define reg_fste_phase_inc_3_0_len 4
+#define reg_fste_phase_inc_3_0_lsb 0
+#define xd_p_reg_fste_phase_inc_11_4    0xA342
+#define reg_fste_phase_inc_11_4_pos 0
+#define reg_fste_phase_inc_11_4_len 8
+#define reg_fste_phase_inc_11_4_lsb 4
+#define xd_p_reg_fste_acum_cost_cnt_max 0xA343
+#define reg_fste_acum_cost_cnt_max_pos 0
+#define reg_fste_acum_cost_cnt_max_len 4
+#define reg_fste_acum_cost_cnt_max_lsb 0
+#define xd_p_reg_fste_step_size_std     0xA343
+#define reg_fste_step_size_std_pos 4
+#define reg_fste_step_size_std_len 4
+#define reg_fste_step_size_std_lsb 0
+#define xd_p_reg_fste_step_size_max     0xA344
+#define reg_fste_step_size_max_pos 0
+#define reg_fste_step_size_max_len 4
+#define reg_fste_step_size_max_lsb 0
+#define xd_p_reg_fste_step_size_min     0xA344
+#define reg_fste_step_size_min_pos 4
+#define reg_fste_step_size_min_len 4
+#define reg_fste_step_size_min_lsb 0
+#define xd_p_reg_fste_frac_step_size_7_0        0xA345
+#define reg_fste_frac_step_size_7_0_pos 0
+#define reg_fste_frac_step_size_7_0_len 8
+#define reg_fste_frac_step_size_7_0_lsb 0
+#define xd_p_reg_fste_frac_step_size_15_8       0xA346
+#define reg_fste_frac_step_size_15_8_pos 0
+#define reg_fste_frac_step_size_15_8_len 8
+#define reg_fste_frac_step_size_15_8_lsb 8
+#define xd_p_reg_fste_frac_step_size_19_16      0xA347
+#define reg_fste_frac_step_size_19_16_pos 0
+#define reg_fste_frac_step_size_19_16_len 4
+#define reg_fste_frac_step_size_19_16_lsb 16
+#define xd_p_reg_fste_rpd_dir_cnt_max   0xA347
+#define reg_fste_rpd_dir_cnt_max_pos 4
+#define reg_fste_rpd_dir_cnt_max_len 4
+#define reg_fste_rpd_dir_cnt_max_lsb 0
+#define xd_p_reg_fste_ehs       0xA348
+#define reg_fste_ehs_pos 0
+#define reg_fste_ehs_len 4
+#define reg_fste_ehs_lsb 0
+#define xd_p_reg_fste_frac_cost_cnt_max_3_0     0xA348
+#define reg_fste_frac_cost_cnt_max_3_0_pos 4
+#define reg_fste_frac_cost_cnt_max_3_0_len 4
+#define reg_fste_frac_cost_cnt_max_3_0_lsb 0
+#define xd_p_reg_fste_frac_cost_cnt_max_9_4     0xA349
+#define reg_fste_frac_cost_cnt_max_9_4_pos 0
+#define reg_fste_frac_cost_cnt_max_9_4_len 6
+#define reg_fste_frac_cost_cnt_max_9_4_lsb 4
+#define xd_p_reg_fste_w0_7_0    0xA34A
+#define reg_fste_w0_7_0_pos 0
+#define reg_fste_w0_7_0_len 8
+#define reg_fste_w0_7_0_lsb 0
+#define xd_p_reg_fste_w0_11_8   0xA34B
+#define reg_fste_w0_11_8_pos 0
+#define reg_fste_w0_11_8_len 4
+#define reg_fste_w0_11_8_lsb 8
+#define xd_p_reg_fste_w1_3_0    0xA34B
+#define reg_fste_w1_3_0_pos 4
+#define reg_fste_w1_3_0_len 4
+#define reg_fste_w1_3_0_lsb 0
+#define xd_p_reg_fste_w1_11_4   0xA34C
+#define reg_fste_w1_11_4_pos 0
+#define reg_fste_w1_11_4_len 8
+#define reg_fste_w1_11_4_lsb 4
+#define xd_p_reg_fste_w2_7_0    0xA34D
+#define reg_fste_w2_7_0_pos 0
+#define reg_fste_w2_7_0_len 8
+#define reg_fste_w2_7_0_lsb 0
+#define xd_p_reg_fste_w2_11_8   0xA34E
+#define reg_fste_w2_11_8_pos 0
+#define reg_fste_w2_11_8_len 4
+#define reg_fste_w2_11_8_lsb 8
+#define xd_p_reg_fste_w3_3_0    0xA34E
+#define reg_fste_w3_3_0_pos 4
+#define reg_fste_w3_3_0_len 4
+#define reg_fste_w3_3_0_lsb 0
+#define xd_p_reg_fste_w3_11_4   0xA34F
+#define reg_fste_w3_11_4_pos 0
+#define reg_fste_w3_11_4_len 8
+#define reg_fste_w3_11_4_lsb 4
+#define xd_p_reg_fste_w4_7_0    0xA350
+#define reg_fste_w4_7_0_pos 0
+#define reg_fste_w4_7_0_len 8
+#define reg_fste_w4_7_0_lsb 0
+#define xd_p_reg_fste_w4_11_8   0xA351
+#define reg_fste_w4_11_8_pos 0
+#define reg_fste_w4_11_8_len 4
+#define reg_fste_w4_11_8_lsb 8
+#define xd_p_reg_fste_w5_3_0    0xA351
+#define reg_fste_w5_3_0_pos 4
+#define reg_fste_w5_3_0_len 4
+#define reg_fste_w5_3_0_lsb 0
+#define xd_p_reg_fste_w5_11_4   0xA352
+#define reg_fste_w5_11_4_pos 0
+#define reg_fste_w5_11_4_len 8
+#define reg_fste_w5_11_4_lsb 4
+#define xd_p_reg_fste_w6_7_0    0xA353
+#define reg_fste_w6_7_0_pos 0
+#define reg_fste_w6_7_0_len 8
+#define reg_fste_w6_7_0_lsb 0
+#define xd_p_reg_fste_w6_11_8   0xA354
+#define reg_fste_w6_11_8_pos 0
+#define reg_fste_w6_11_8_len 4
+#define reg_fste_w6_11_8_lsb 8
+#define xd_p_reg_fste_w7_3_0    0xA354
+#define reg_fste_w7_3_0_pos 4
+#define reg_fste_w7_3_0_len 4
+#define reg_fste_w7_3_0_lsb 0
+#define xd_p_reg_fste_w7_11_4   0xA355
+#define reg_fste_w7_11_4_pos 0
+#define reg_fste_w7_11_4_len 8
+#define reg_fste_w7_11_4_lsb 4
+#define xd_p_reg_fste_w8_7_0    0xA356
+#define reg_fste_w8_7_0_pos 0
+#define reg_fste_w8_7_0_len 8
+#define reg_fste_w8_7_0_lsb 0
+#define xd_p_reg_fste_w8_11_8   0xA357
+#define reg_fste_w8_11_8_pos 0
+#define reg_fste_w8_11_8_len 4
+#define reg_fste_w8_11_8_lsb 8
+#define xd_p_reg_fste_w9_3_0    0xA357
+#define reg_fste_w9_3_0_pos 4
+#define reg_fste_w9_3_0_len 4
+#define reg_fste_w9_3_0_lsb 0
+#define xd_p_reg_fste_w9_11_4   0xA358
+#define reg_fste_w9_11_4_pos 0
+#define reg_fste_w9_11_4_len 8
+#define reg_fste_w9_11_4_lsb 4
+#define xd_p_reg_fste_wa_7_0    0xA359
+#define reg_fste_wa_7_0_pos 0
+#define reg_fste_wa_7_0_len 8
+#define reg_fste_wa_7_0_lsb 0
+#define xd_p_reg_fste_wa_11_8   0xA35A
+#define reg_fste_wa_11_8_pos 0
+#define reg_fste_wa_11_8_len 4
+#define reg_fste_wa_11_8_lsb 8
+#define xd_p_reg_fste_wb_3_0    0xA35A
+#define reg_fste_wb_3_0_pos 4
+#define reg_fste_wb_3_0_len 4
+#define reg_fste_wb_3_0_lsb 0
+#define xd_p_reg_fste_wb_11_4   0xA35B
+#define reg_fste_wb_11_4_pos 0
+#define reg_fste_wb_11_4_len 8
+#define reg_fste_wb_11_4_lsb 4
+#define xd_r_fd_fste_i_adj      0xA35C
+#define fd_fste_i_adj_pos 0
+#define fd_fste_i_adj_len 5
+#define fd_fste_i_adj_lsb 0
+#define xd_r_fd_fste_f_adj_7_0  0xA35D
+#define fd_fste_f_adj_7_0_pos 0
+#define fd_fste_f_adj_7_0_len 8
+#define fd_fste_f_adj_7_0_lsb 0
+#define xd_r_fd_fste_f_adj_15_8 0xA35E
+#define fd_fste_f_adj_15_8_pos 0
+#define fd_fste_f_adj_15_8_len 8
+#define fd_fste_f_adj_15_8_lsb 8
+#define xd_r_fd_fste_f_adj_19_16        0xA35F
+#define fd_fste_f_adj_19_16_pos 0
+#define fd_fste_f_adj_19_16_len 4
+#define fd_fste_f_adj_19_16_lsb 16
+#define xd_p_reg_feq_Leak_Bypass        0xA366
+#define reg_feq_Leak_Bypass_pos 0
+#define reg_feq_Leak_Bypass_len 1
+#define reg_feq_Leak_Bypass_lsb 0
+#define xd_p_reg_feq_Leak_Mneg1 0xA366
+#define reg_feq_Leak_Mneg1_pos 1
+#define reg_feq_Leak_Mneg1_len 3
+#define reg_feq_Leak_Mneg1_lsb 0
+#define xd_p_reg_feq_Leak_B_ShiftQ      0xA366
+#define reg_feq_Leak_B_ShiftQ_pos 4
+#define reg_feq_Leak_B_ShiftQ_len 4
+#define reg_feq_Leak_B_ShiftQ_lsb 0
+#define xd_p_reg_feq_Leak_B_Float0      0xA367
+#define reg_feq_Leak_B_Float0_pos 0
+#define reg_feq_Leak_B_Float0_len 8
+#define reg_feq_Leak_B_Float0_lsb 0
+#define xd_p_reg_feq_Leak_B_Float1      0xA368
+#define reg_feq_Leak_B_Float1_pos 0
+#define reg_feq_Leak_B_Float1_len 8
+#define reg_feq_Leak_B_Float1_lsb 0
+#define xd_p_reg_feq_Leak_B_Float2      0xA369
+#define reg_feq_Leak_B_Float2_pos 0
+#define reg_feq_Leak_B_Float2_len 8
+#define reg_feq_Leak_B_Float2_lsb 0
+#define xd_p_reg_feq_Leak_B_Float3      0xA36A
+#define reg_feq_Leak_B_Float3_pos 0
+#define reg_feq_Leak_B_Float3_len 8
+#define reg_feq_Leak_B_Float3_lsb 0
+#define xd_p_reg_feq_Leak_B_Float4      0xA36B
+#define reg_feq_Leak_B_Float4_pos 0
+#define reg_feq_Leak_B_Float4_len 8
+#define reg_feq_Leak_B_Float4_lsb 0
+#define xd_p_reg_feq_Leak_B_Float5      0xA36C
+#define reg_feq_Leak_B_Float5_pos 0
+#define reg_feq_Leak_B_Float5_len 8
+#define reg_feq_Leak_B_Float5_lsb 0
+#define xd_p_reg_feq_Leak_B_Float6      0xA36D
+#define reg_feq_Leak_B_Float6_pos 0
+#define reg_feq_Leak_B_Float6_len 8
+#define reg_feq_Leak_B_Float6_lsb 0
+#define xd_p_reg_feq_Leak_B_Float7      0xA36E
+#define reg_feq_Leak_B_Float7_pos 0
+#define reg_feq_Leak_B_Float7_len 8
+#define reg_feq_Leak_B_Float7_lsb 0
+#define xd_r_reg_feq_data_h2_7_0        0xA36F
+#define reg_feq_data_h2_7_0_pos 0
+#define reg_feq_data_h2_7_0_len 8
+#define reg_feq_data_h2_7_0_lsb 0
+#define xd_r_reg_feq_data_h2_9_8        0xA370
+#define reg_feq_data_h2_9_8_pos 0
+#define reg_feq_data_h2_9_8_len 2
+#define reg_feq_data_h2_9_8_lsb 8
+#define xd_p_reg_feq_leak_use_slice_tps 0xA371
+#define reg_feq_leak_use_slice_tps_pos 0
+#define reg_feq_leak_use_slice_tps_len 1
+#define reg_feq_leak_use_slice_tps_lsb 0
+#define xd_p_reg_feq_read_update        0xA371
+#define reg_feq_read_update_pos 1
+#define reg_feq_read_update_len 1
+#define reg_feq_read_update_lsb 0
+#define xd_p_reg_feq_data_vld   0xA371
+#define reg_feq_data_vld_pos 2
+#define reg_feq_data_vld_len 1
+#define reg_feq_data_vld_lsb 0
+#define xd_p_reg_feq_tone_idx_4_0       0xA371
+#define reg_feq_tone_idx_4_0_pos 3
+#define reg_feq_tone_idx_4_0_len 5
+#define reg_feq_tone_idx_4_0_lsb 0
+#define xd_p_reg_feq_tone_idx_12_5      0xA372
+#define reg_feq_tone_idx_12_5_pos 0
+#define reg_feq_tone_idx_12_5_len 8
+#define reg_feq_tone_idx_12_5_lsb 5
+#define xd_r_reg_feq_data_re_7_0        0xA373
+#define reg_feq_data_re_7_0_pos 0
+#define reg_feq_data_re_7_0_len 8
+#define reg_feq_data_re_7_0_lsb 0
+#define xd_r_reg_feq_data_re_10_8       0xA374
+#define reg_feq_data_re_10_8_pos 0
+#define reg_feq_data_re_10_8_len 3
+#define reg_feq_data_re_10_8_lsb 8
+#define xd_r_reg_feq_data_im_7_0        0xA375
+#define reg_feq_data_im_7_0_pos 0
+#define reg_feq_data_im_7_0_len 8
+#define reg_feq_data_im_7_0_lsb 0
+#define xd_r_reg_feq_data_im_10_8       0xA376
+#define reg_feq_data_im_10_8_pos 0
+#define reg_feq_data_im_10_8_len 3
+#define reg_feq_data_im_10_8_lsb 8
+#define xd_r_reg_feq_y_re       0xA377
+#define reg_feq_y_re_pos 0
+#define reg_feq_y_re_len 8
+#define reg_feq_y_re_lsb 0
+#define xd_r_reg_feq_y_im       0xA378
+#define reg_feq_y_im_pos 0
+#define reg_feq_y_im_len 8
+#define reg_feq_y_im_lsb 0
+#define xd_r_reg_feq_h_re_7_0   0xA379
+#define reg_feq_h_re_7_0_pos 0
+#define reg_feq_h_re_7_0_len 8
+#define reg_feq_h_re_7_0_lsb 0
+#define xd_r_reg_feq_h_re_8     0xA37A
+#define reg_feq_h_re_8_pos 0
+#define reg_feq_h_re_8_len 1
+#define reg_feq_h_re_8_lsb 0
+#define xd_r_reg_feq_h_im_7_0   0xA37B
+#define reg_feq_h_im_7_0_pos 0
+#define reg_feq_h_im_7_0_len 8
+#define reg_feq_h_im_7_0_lsb 0
+#define xd_r_reg_feq_h_im_8     0xA37C
+#define reg_feq_h_im_8_pos 0
+#define reg_feq_h_im_8_len 1
+#define reg_feq_h_im_8_lsb 0
+#define xd_p_fec_super_frm_unit_7_0     0xA380
+#define fec_super_frm_unit_7_0_pos 0
+#define fec_super_frm_unit_7_0_len 8
+#define fec_super_frm_unit_7_0_lsb 0
+#define xd_p_fec_super_frm_unit_15_8    0xA381
+#define fec_super_frm_unit_15_8_pos 0
+#define fec_super_frm_unit_15_8_len 8
+#define fec_super_frm_unit_15_8_lsb 8
+#define xd_r_fec_vtb_err_bit_cnt_7_0    0xA382
+#define fec_vtb_err_bit_cnt_7_0_pos 0
+#define fec_vtb_err_bit_cnt_7_0_len 8
+#define fec_vtb_err_bit_cnt_7_0_lsb 0
+#define xd_r_fec_vtb_err_bit_cnt_15_8   0xA383
+#define fec_vtb_err_bit_cnt_15_8_pos 0
+#define fec_vtb_err_bit_cnt_15_8_len 8
+#define fec_vtb_err_bit_cnt_15_8_lsb 8
+#define xd_r_fec_vtb_err_bit_cnt_23_16  0xA384
+#define fec_vtb_err_bit_cnt_23_16_pos 0
+#define fec_vtb_err_bit_cnt_23_16_len 8
+#define fec_vtb_err_bit_cnt_23_16_lsb 16
+#define xd_p_fec_rsd_packet_unit_7_0    0xA385
+#define fec_rsd_packet_unit_7_0_pos 0
+#define fec_rsd_packet_unit_7_0_len 8
+#define fec_rsd_packet_unit_7_0_lsb 0
+#define xd_p_fec_rsd_packet_unit_15_8   0xA386
+#define fec_rsd_packet_unit_15_8_pos 0
+#define fec_rsd_packet_unit_15_8_len 8
+#define fec_rsd_packet_unit_15_8_lsb 8
+#define xd_r_fec_rsd_bit_err_cnt_7_0    0xA387
+#define fec_rsd_bit_err_cnt_7_0_pos 0
+#define fec_rsd_bit_err_cnt_7_0_len 8
+#define fec_rsd_bit_err_cnt_7_0_lsb 0
+#define xd_r_fec_rsd_bit_err_cnt_15_8   0xA388
+#define fec_rsd_bit_err_cnt_15_8_pos 0
+#define fec_rsd_bit_err_cnt_15_8_len 8
+#define fec_rsd_bit_err_cnt_15_8_lsb 8
+#define xd_r_fec_rsd_bit_err_cnt_23_16  0xA389
+#define fec_rsd_bit_err_cnt_23_16_pos 0
+#define fec_rsd_bit_err_cnt_23_16_len 8
+#define fec_rsd_bit_err_cnt_23_16_lsb 16
+#define xd_r_fec_rsd_abort_packet_cnt_7_0       0xA38A
+#define fec_rsd_abort_packet_cnt_7_0_pos 0
+#define fec_rsd_abort_packet_cnt_7_0_len 8
+#define fec_rsd_abort_packet_cnt_7_0_lsb 0
+#define xd_r_fec_rsd_abort_packet_cnt_15_8      0xA38B
+#define fec_rsd_abort_packet_cnt_15_8_pos 0
+#define fec_rsd_abort_packet_cnt_15_8_len 8
+#define fec_rsd_abort_packet_cnt_15_8_lsb 8
+#define xd_p_fec_RSD_PKT_NUM_PER_UNIT_7_0       0xA38C
+#define fec_RSD_PKT_NUM_PER_UNIT_7_0_pos 0
+#define fec_RSD_PKT_NUM_PER_UNIT_7_0_len 8
+#define fec_RSD_PKT_NUM_PER_UNIT_7_0_lsb 0
+#define xd_p_fec_RSD_PKT_NUM_PER_UNIT_15_8      0xA38D
+#define fec_RSD_PKT_NUM_PER_UNIT_15_8_pos 0
+#define fec_RSD_PKT_NUM_PER_UNIT_15_8_len 8
+#define fec_RSD_PKT_NUM_PER_UNIT_15_8_lsb 8
+#define xd_p_fec_RS_TH_1_7_0    0xA38E
+#define fec_RS_TH_1_7_0_pos 0
+#define fec_RS_TH_1_7_0_len 8
+#define fec_RS_TH_1_7_0_lsb 0
+#define xd_p_fec_RS_TH_1_15_8   0xA38F
+#define fec_RS_TH_1_15_8_pos 0
+#define fec_RS_TH_1_15_8_len 8
+#define fec_RS_TH_1_15_8_lsb 8
+#define xd_p_fec_RS_TH_2        0xA390
+#define fec_RS_TH_2_pos 0
+#define fec_RS_TH_2_len 8
+#define fec_RS_TH_2_lsb 0
+#define xd_p_fec_mon_en 0xA391
+#define fec_mon_en_pos 0
+#define fec_mon_en_len 1
+#define fec_mon_en_lsb 0
+#define xd_p_reg_b8to47 0xA391
+#define reg_b8to47_pos 1
+#define reg_b8to47_len 1
+#define reg_b8to47_lsb 0
+#define xd_p_reg_rsd_sync_rep   0xA391
+#define reg_rsd_sync_rep_pos 2
+#define reg_rsd_sync_rep_len 1
+#define reg_rsd_sync_rep_lsb 0
+#define xd_p_fec_rsd_retrain_rst        0xA391
+#define fec_rsd_retrain_rst_pos 3
+#define fec_rsd_retrain_rst_len 1
+#define fec_rsd_retrain_rst_lsb 0
+#define xd_r_fec_rsd_ber_rdy    0xA391
+#define fec_rsd_ber_rdy_pos 4
+#define fec_rsd_ber_rdy_len 1
+#define fec_rsd_ber_rdy_lsb 0
+#define xd_p_fec_rsd_ber_rst    0xA391
+#define fec_rsd_ber_rst_pos 5
+#define fec_rsd_ber_rst_len 1
+#define fec_rsd_ber_rst_lsb 0
+#define xd_r_fec_vtb_ber_rdy    0xA391
+#define fec_vtb_ber_rdy_pos 6
+#define fec_vtb_ber_rdy_len 1
+#define fec_vtb_ber_rdy_lsb 0
+#define xd_p_fec_vtb_ber_rst    0xA391
+#define fec_vtb_ber_rst_pos 7
+#define fec_vtb_ber_rst_len 1
+#define fec_vtb_ber_rst_lsb 0
+#define xd_p_reg_vtb_clk40en    0xA392
+#define reg_vtb_clk40en_pos 0
+#define reg_vtb_clk40en_len 1
+#define reg_vtb_clk40en_lsb 0
+#define xd_p_fec_vtb_rsd_mon_en 0xA392
+#define fec_vtb_rsd_mon_en_pos 1
+#define fec_vtb_rsd_mon_en_len 1
+#define fec_vtb_rsd_mon_en_lsb 0
+#define xd_p_reg_fec_data_en    0xA392
+#define reg_fec_data_en_pos 2
+#define reg_fec_data_en_len 1
+#define reg_fec_data_en_lsb 0
+#define xd_p_fec_dummy_reg_2    0xA392
+#define fec_dummy_reg_2_pos 3
+#define fec_dummy_reg_2_len 3
+#define fec_dummy_reg_2_lsb 0
+#define xd_p_reg_sync_chk       0xA392
+#define reg_sync_chk_pos 6
+#define reg_sync_chk_len 1
+#define reg_sync_chk_lsb 0
+#define xd_p_fec_rsd_bypass     0xA392
+#define fec_rsd_bypass_pos 7
+#define fec_rsd_bypass_len 1
+#define fec_rsd_bypass_lsb 0
+#define xd_p_fec_sw_rst 0xA393
+#define fec_sw_rst_pos 0
+#define fec_sw_rst_len 1
+#define fec_sw_rst_lsb 0
+#define xd_r_fec_vtb_pm_crc     0xA394
+#define fec_vtb_pm_crc_pos 0
+#define fec_vtb_pm_crc_len 8
+#define fec_vtb_pm_crc_lsb 0
+#define xd_r_fec_vtb_tb_7_crc   0xA395
+#define fec_vtb_tb_7_crc_pos 0
+#define fec_vtb_tb_7_crc_len 8
+#define fec_vtb_tb_7_crc_lsb 0
+#define xd_r_fec_vtb_tb_6_crc   0xA396
+#define fec_vtb_tb_6_crc_pos 0
+#define fec_vtb_tb_6_crc_len 8
+#define fec_vtb_tb_6_crc_lsb 0
+#define xd_r_fec_vtb_tb_5_crc   0xA397
+#define fec_vtb_tb_5_crc_pos 0
+#define fec_vtb_tb_5_crc_len 8
+#define fec_vtb_tb_5_crc_lsb 0
+#define xd_r_fec_vtb_tb_4_crc   0xA398
+#define fec_vtb_tb_4_crc_pos 0
+#define fec_vtb_tb_4_crc_len 8
+#define fec_vtb_tb_4_crc_lsb 0
+#define xd_r_fec_vtb_tb_3_crc   0xA399
+#define fec_vtb_tb_3_crc_pos 0
+#define fec_vtb_tb_3_crc_len 8
+#define fec_vtb_tb_3_crc_lsb 0
+#define xd_r_fec_vtb_tb_2_crc   0xA39A
+#define fec_vtb_tb_2_crc_pos 0
+#define fec_vtb_tb_2_crc_len 8
+#define fec_vtb_tb_2_crc_lsb 0
+#define xd_r_fec_vtb_tb_1_crc   0xA39B
+#define fec_vtb_tb_1_crc_pos 0
+#define fec_vtb_tb_1_crc_len 8
+#define fec_vtb_tb_1_crc_lsb 0
+#define xd_r_fec_vtb_tb_0_crc   0xA39C
+#define fec_vtb_tb_0_crc_pos 0
+#define fec_vtb_tb_0_crc_len 8
+#define fec_vtb_tb_0_crc_lsb 0
+#define xd_r_fec_rsd_bank0_crc  0xA39D
+#define fec_rsd_bank0_crc_pos 0
+#define fec_rsd_bank0_crc_len 8
+#define fec_rsd_bank0_crc_lsb 0
+#define xd_r_fec_rsd_bank1_crc  0xA39E
+#define fec_rsd_bank1_crc_pos 0
+#define fec_rsd_bank1_crc_len 8
+#define fec_rsd_bank1_crc_lsb 0
+#define xd_r_fec_idi_vtb_crc    0xA39F
+#define fec_idi_vtb_crc_pos 0
+#define fec_idi_vtb_crc_len 8
+#define fec_idi_vtb_crc_lsb 0
+#define xd_g_reg_tpsd_txmod     0xA3C0
+#define reg_tpsd_txmod_pos 0
+#define reg_tpsd_txmod_len 2
+#define reg_tpsd_txmod_lsb 0
+#define xd_g_reg_tpsd_gi        0xA3C0
+#define reg_tpsd_gi_pos 2
+#define reg_tpsd_gi_len 2
+#define reg_tpsd_gi_lsb 0
+#define xd_g_reg_tpsd_hier      0xA3C0
+#define reg_tpsd_hier_pos 4
+#define reg_tpsd_hier_len 3
+#define reg_tpsd_hier_lsb 0
+#define xd_g_reg_bw     0xA3C1
+#define reg_bw_pos 2
+#define reg_bw_len 2
+#define reg_bw_lsb 0
+#define xd_g_reg_dec_pri        0xA3C1
+#define reg_dec_pri_pos 4
+#define reg_dec_pri_len 1
+#define reg_dec_pri_lsb 0
+#define xd_g_reg_tpsd_const     0xA3C1
+#define reg_tpsd_const_pos 6
+#define reg_tpsd_const_len 2
+#define reg_tpsd_const_lsb 0
+#define xd_g_reg_tpsd_hpcr      0xA3C2
+#define reg_tpsd_hpcr_pos 0
+#define reg_tpsd_hpcr_len 3
+#define reg_tpsd_hpcr_lsb 0
+#define xd_g_reg_tpsd_lpcr      0xA3C2
+#define reg_tpsd_lpcr_pos 3
+#define reg_tpsd_lpcr_len 3
+#define reg_tpsd_lpcr_lsb 0
+#define xd_g_reg_ofsm_clk       0xA3D0
+#define reg_ofsm_clk_pos 0
+#define reg_ofsm_clk_len 3
+#define reg_ofsm_clk_lsb 0
+#define xd_g_reg_fclk_cfg       0xA3D1
+#define reg_fclk_cfg_pos 0
+#define reg_fclk_cfg_len 1
+#define reg_fclk_cfg_lsb 0
+#define xd_g_reg_fclk_idi       0xA3D1
+#define reg_fclk_idi_pos 1
+#define reg_fclk_idi_len 1
+#define reg_fclk_idi_lsb 0
+#define xd_g_reg_fclk_odi       0xA3D1
+#define reg_fclk_odi_pos 2
+#define reg_fclk_odi_len 1
+#define reg_fclk_odi_lsb 0
+#define xd_g_reg_fclk_rsd       0xA3D1
+#define reg_fclk_rsd_pos 3
+#define reg_fclk_rsd_len 1
+#define reg_fclk_rsd_lsb 0
+#define xd_g_reg_fclk_vtb       0xA3D1
+#define reg_fclk_vtb_pos 4
+#define reg_fclk_vtb_len 1
+#define reg_fclk_vtb_lsb 0
+#define xd_g_reg_fclk_cste      0xA3D1
+#define reg_fclk_cste_pos 5
+#define reg_fclk_cste_len 1
+#define reg_fclk_cste_lsb 0
+#define xd_g_reg_fclk_mp2if     0xA3D1
+#define reg_fclk_mp2if_pos 6
+#define reg_fclk_mp2if_len 1
+#define reg_fclk_mp2if_lsb 0
+#define xd_I2C_i2c_m_slave_addr 0xA400
+#define i2c_m_slave_addr_pos 0
+#define i2c_m_slave_addr_len 8
+#define i2c_m_slave_addr_lsb 0
+#define xd_I2C_i2c_m_data1      0xA401
+#define i2c_m_data1_pos 0
+#define i2c_m_data1_len 8
+#define i2c_m_data1_lsb 0
+#define xd_I2C_i2c_m_data2      0xA402
+#define i2c_m_data2_pos 0
+#define i2c_m_data2_len 8
+#define i2c_m_data2_lsb 0
+#define xd_I2C_i2c_m_data3      0xA403
+#define i2c_m_data3_pos 0
+#define i2c_m_data3_len 8
+#define i2c_m_data3_lsb 0
+#define xd_I2C_i2c_m_data4      0xA404
+#define i2c_m_data4_pos 0
+#define i2c_m_data4_len 8
+#define i2c_m_data4_lsb 0
+#define xd_I2C_i2c_m_data5      0xA405
+#define i2c_m_data5_pos 0
+#define i2c_m_data5_len 8
+#define i2c_m_data5_lsb 0
+#define xd_I2C_i2c_m_data6      0xA406
+#define i2c_m_data6_pos 0
+#define i2c_m_data6_len 8
+#define i2c_m_data6_lsb 0
+#define xd_I2C_i2c_m_data7      0xA407
+#define i2c_m_data7_pos 0
+#define i2c_m_data7_len 8
+#define i2c_m_data7_lsb 0
+#define xd_I2C_i2c_m_data8      0xA408
+#define i2c_m_data8_pos 0
+#define i2c_m_data8_len 8
+#define i2c_m_data8_lsb 0
+#define xd_I2C_i2c_m_data9      0xA409
+#define i2c_m_data9_pos 0
+#define i2c_m_data9_len 8
+#define i2c_m_data9_lsb 0
+#define xd_I2C_i2c_m_data10     0xA40A
+#define i2c_m_data10_pos 0
+#define i2c_m_data10_len 8
+#define i2c_m_data10_lsb 0
+#define xd_I2C_i2c_m_data11     0xA40B
+#define i2c_m_data11_pos 0
+#define i2c_m_data11_len 8
+#define i2c_m_data11_lsb 0
+#define xd_I2C_i2c_m_cmd_rw     0xA40C
+#define i2c_m_cmd_rw_pos 0
+#define i2c_m_cmd_rw_len 1
+#define i2c_m_cmd_rw_lsb 0
+#define xd_I2C_i2c_m_cmd_rwlen  0xA40C
+#define i2c_m_cmd_rwlen_pos 3
+#define i2c_m_cmd_rwlen_len 4
+#define i2c_m_cmd_rwlen_lsb 0
+#define xd_I2C_i2c_m_status_cmd_exe     0xA40D
+#define i2c_m_status_cmd_exe_pos 0
+#define i2c_m_status_cmd_exe_len 1
+#define i2c_m_status_cmd_exe_lsb 0
+#define xd_I2C_i2c_m_status_wdat_done   0xA40D
+#define i2c_m_status_wdat_done_pos 1
+#define i2c_m_status_wdat_done_len 1
+#define i2c_m_status_wdat_done_lsb 0
+#define xd_I2C_i2c_m_status_wdat_fail   0xA40D
+#define i2c_m_status_wdat_fail_pos 2
+#define i2c_m_status_wdat_fail_len 1
+#define i2c_m_status_wdat_fail_lsb 0
+#define xd_I2C_i2c_m_period     0xA40E
+#define i2c_m_period_pos 0
+#define i2c_m_period_len 8
+#define i2c_m_period_lsb 0
+#define xd_I2C_i2c_m_reg_msb_lsb        0xA40F
+#define i2c_m_reg_msb_lsb_pos 0
+#define i2c_m_reg_msb_lsb_len 1
+#define i2c_m_reg_msb_lsb_lsb 0
+#define xd_I2C_reg_ofdm_rst     0xA40F
+#define reg_ofdm_rst_pos 1
+#define reg_ofdm_rst_len 1
+#define reg_ofdm_rst_lsb 0
+#define xd_I2C_reg_sample_period_on_tuner       0xA40F
+#define reg_sample_period_on_tuner_pos 2
+#define reg_sample_period_on_tuner_len 1
+#define reg_sample_period_on_tuner_lsb 0
+#define xd_I2C_reg_rst_i2c      0xA40F
+#define reg_rst_i2c_pos 3
+#define reg_rst_i2c_len 1
+#define reg_rst_i2c_lsb 0
+#define xd_I2C_reg_ofdm_rst_en  0xA40F
+#define reg_ofdm_rst_en_pos 4
+#define reg_ofdm_rst_en_len 1
+#define reg_ofdm_rst_en_lsb 0
+#define xd_I2C_reg_tuner_sda_sync_on    0xA40F
+#define reg_tuner_sda_sync_on_pos 5
+#define reg_tuner_sda_sync_on_len 1
+#define reg_tuner_sda_sync_on_lsb 0
+#define xd_p_mp2if_data_access_disable_ofsm     0xA500
+#define mp2if_data_access_disable_ofsm_pos 0
+#define mp2if_data_access_disable_ofsm_len 1
+#define mp2if_data_access_disable_ofsm_lsb 0
+#define xd_p_reg_mp2_sw_rst_ofsm        0xA500
+#define reg_mp2_sw_rst_ofsm_pos 1
+#define reg_mp2_sw_rst_ofsm_len 1
+#define reg_mp2_sw_rst_ofsm_lsb 0
+#define xd_p_reg_mp2if_clk_en_ofsm      0xA500
+#define reg_mp2if_clk_en_ofsm_pos 2
+#define reg_mp2if_clk_en_ofsm_len 1
+#define reg_mp2if_clk_en_ofsm_lsb 0
+#define xd_r_mp2if_sync_byte_locked     0xA500
+#define mp2if_sync_byte_locked_pos 3
+#define mp2if_sync_byte_locked_len 1
+#define mp2if_sync_byte_locked_lsb 0
+#define xd_r_mp2if_ts_not_188   0xA500
+#define mp2if_ts_not_188_pos 4
+#define mp2if_ts_not_188_len 1
+#define mp2if_ts_not_188_lsb 0
+#define xd_r_mp2if_psb_empty    0xA500
+#define mp2if_psb_empty_pos 5
+#define mp2if_psb_empty_len 1
+#define mp2if_psb_empty_lsb 0
+#define xd_r_mp2if_psb_overflow 0xA500
+#define mp2if_psb_overflow_pos 6
+#define mp2if_psb_overflow_len 1
+#define mp2if_psb_overflow_lsb 0
+#define xd_p_mp2if_keep_sf_sync_byte_ofsm       0xA500
+#define mp2if_keep_sf_sync_byte_ofsm_pos 7
+#define mp2if_keep_sf_sync_byte_ofsm_len 1
+#define mp2if_keep_sf_sync_byte_ofsm_lsb 0
+#define xd_r_mp2if_psb_mp2if_num_pkt    0xA501
+#define mp2if_psb_mp2if_num_pkt_pos 0
+#define mp2if_psb_mp2if_num_pkt_len 6
+#define mp2if_psb_mp2if_num_pkt_lsb 0
+#define xd_p_reg_mpeg_full_speed_ofsm   0xA501
+#define reg_mpeg_full_speed_ofsm_pos 6
+#define reg_mpeg_full_speed_ofsm_len 1
+#define reg_mpeg_full_speed_ofsm_lsb 0
+#define xd_p_mp2if_mpeg_ser_mode_ofsm   0xA501
+#define mp2if_mpeg_ser_mode_ofsm_pos 7
+#define mp2if_mpeg_ser_mode_ofsm_len 1
+#define mp2if_mpeg_ser_mode_ofsm_lsb 0
+#define xd_p_reg_sw_mon51       0xA600
+#define reg_sw_mon51_pos 0
+#define reg_sw_mon51_len 8
+#define reg_sw_mon51_lsb 0
+#define xd_p_reg_top_pcsel      0xA601
+#define reg_top_pcsel_pos 0
+#define reg_top_pcsel_len 1
+#define reg_top_pcsel_lsb 0
+#define xd_p_reg_top_rs232      0xA601
+#define reg_top_rs232_pos 1
+#define reg_top_rs232_len 1
+#define reg_top_rs232_lsb 0
+#define xd_p_reg_top_pcout      0xA601
+#define reg_top_pcout_pos 2
+#define reg_top_pcout_len 1
+#define reg_top_pcout_lsb 0
+#define xd_p_reg_top_debug      0xA601
+#define reg_top_debug_pos 3
+#define reg_top_debug_len 1
+#define reg_top_debug_lsb 0
+#define xd_p_reg_top_adcdly     0xA601
+#define reg_top_adcdly_pos 4
+#define reg_top_adcdly_len 2
+#define reg_top_adcdly_lsb 0
+#define xd_p_reg_top_pwrdw      0xA601
+#define reg_top_pwrdw_pos 6
+#define reg_top_pwrdw_len 1
+#define reg_top_pwrdw_lsb 0
+#define xd_p_reg_top_pwrdw_inv  0xA601
+#define reg_top_pwrdw_inv_pos 7
+#define reg_top_pwrdw_inv_len 1
+#define reg_top_pwrdw_inv_lsb 0
+#define xd_p_reg_top_int_inv    0xA602
+#define reg_top_int_inv_pos 0
+#define reg_top_int_inv_len 1
+#define reg_top_int_inv_lsb 0
+#define xd_p_reg_top_dio_sel    0xA602
+#define reg_top_dio_sel_pos 1
+#define reg_top_dio_sel_len 1
+#define reg_top_dio_sel_lsb 0
+#define xd_p_reg_top_gpioon0    0xA603
+#define reg_top_gpioon0_pos 0
+#define reg_top_gpioon0_len 1
+#define reg_top_gpioon0_lsb 0
+#define xd_p_reg_top_gpioon1    0xA603
+#define reg_top_gpioon1_pos 1
+#define reg_top_gpioon1_len 1
+#define reg_top_gpioon1_lsb 0
+#define xd_p_reg_top_gpioon2    0xA603
+#define reg_top_gpioon2_pos 2
+#define reg_top_gpioon2_len 1
+#define reg_top_gpioon2_lsb 0
+#define xd_p_reg_top_gpioon3    0xA603
+#define reg_top_gpioon3_pos 3
+#define reg_top_gpioon3_len 1
+#define reg_top_gpioon3_lsb 0
+#define xd_p_reg_top_lockon1    0xA603
+#define reg_top_lockon1_pos 4
+#define reg_top_lockon1_len 1
+#define reg_top_lockon1_lsb 0
+#define xd_p_reg_top_lockon2    0xA603
+#define reg_top_lockon2_pos 5
+#define reg_top_lockon2_len 1
+#define reg_top_lockon2_lsb 0
+#define xd_p_reg_top_gpioo0     0xA604
+#define reg_top_gpioo0_pos 0
+#define reg_top_gpioo0_len 1
+#define reg_top_gpioo0_lsb 0
+#define xd_p_reg_top_gpioo1     0xA604
+#define reg_top_gpioo1_pos 1
+#define reg_top_gpioo1_len 1
+#define reg_top_gpioo1_lsb 0
+#define xd_p_reg_top_gpioo2     0xA604
+#define reg_top_gpioo2_pos 2
+#define reg_top_gpioo2_len 1
+#define reg_top_gpioo2_lsb 0
+#define xd_p_reg_top_gpioo3     0xA604
+#define reg_top_gpioo3_pos 3
+#define reg_top_gpioo3_len 1
+#define reg_top_gpioo3_lsb 0
+#define xd_p_reg_top_lock1      0xA604
+#define reg_top_lock1_pos 4
+#define reg_top_lock1_len 1
+#define reg_top_lock1_lsb 0
+#define xd_p_reg_top_lock2      0xA604
+#define reg_top_lock2_pos 5
+#define reg_top_lock2_len 1
+#define reg_top_lock2_lsb 0
+#define xd_p_reg_top_gpioen0    0xA605
+#define reg_top_gpioen0_pos 0
+#define reg_top_gpioen0_len 1
+#define reg_top_gpioen0_lsb 0
+#define xd_p_reg_top_gpioen1    0xA605
+#define reg_top_gpioen1_pos 1
+#define reg_top_gpioen1_len 1
+#define reg_top_gpioen1_lsb 0
+#define xd_p_reg_top_gpioen2    0xA605
+#define reg_top_gpioen2_pos 2
+#define reg_top_gpioen2_len 1
+#define reg_top_gpioen2_lsb 0
+#define xd_p_reg_top_gpioen3    0xA605
+#define reg_top_gpioen3_pos 3
+#define reg_top_gpioen3_len 1
+#define reg_top_gpioen3_lsb 0
+#define xd_p_reg_top_locken1    0xA605
+#define reg_top_locken1_pos 4
+#define reg_top_locken1_len 1
+#define reg_top_locken1_lsb 0
+#define xd_p_reg_top_locken2    0xA605
+#define reg_top_locken2_pos 5
+#define reg_top_locken2_len 1
+#define reg_top_locken2_lsb 0
+#define xd_r_reg_top_gpioi0     0xA606
+#define reg_top_gpioi0_pos 0
+#define reg_top_gpioi0_len 1
+#define reg_top_gpioi0_lsb 0
+#define xd_r_reg_top_gpioi1     0xA606
+#define reg_top_gpioi1_pos 1
+#define reg_top_gpioi1_len 1
+#define reg_top_gpioi1_lsb 0
+#define xd_r_reg_top_gpioi2     0xA606
+#define reg_top_gpioi2_pos 2
+#define reg_top_gpioi2_len 1
+#define reg_top_gpioi2_lsb 0
+#define xd_r_reg_top_gpioi3     0xA606
+#define reg_top_gpioi3_pos 3
+#define reg_top_gpioi3_len 1
+#define reg_top_gpioi3_lsb 0
+#define xd_r_reg_top_locki1     0xA606
+#define reg_top_locki1_pos 4
+#define reg_top_locki1_len 1
+#define reg_top_locki1_lsb 0
+#define xd_r_reg_top_locki2     0xA606
+#define reg_top_locki2_pos 5
+#define reg_top_locki2_len 1
+#define reg_top_locki2_lsb 0
+#define xd_p_reg_dummy_7_0      0xA608
+#define reg_dummy_7_0_pos 0
+#define reg_dummy_7_0_len 8
+#define reg_dummy_7_0_lsb 0
+#define xd_p_reg_dummy_15_8     0xA609
+#define reg_dummy_15_8_pos 0
+#define reg_dummy_15_8_len 8
+#define reg_dummy_15_8_lsb 8
+#define xd_p_reg_dummy_23_16    0xA60A
+#define reg_dummy_23_16_pos 0
+#define reg_dummy_23_16_len 8
+#define reg_dummy_23_16_lsb 16
+#define xd_p_reg_dummy_31_24    0xA60B
+#define reg_dummy_31_24_pos 0
+#define reg_dummy_31_24_len 8
+#define reg_dummy_31_24_lsb 24
+#define xd_p_reg_dummy_39_32    0xA60C
+#define reg_dummy_39_32_pos 0
+#define reg_dummy_39_32_len 8
+#define reg_dummy_39_32_lsb 32
+#define xd_p_reg_dummy_47_40    0xA60D
+#define reg_dummy_47_40_pos 0
+#define reg_dummy_47_40_len 8
+#define reg_dummy_47_40_lsb 40
+#define xd_p_reg_dummy_55_48    0xA60E
+#define reg_dummy_55_48_pos 0
+#define reg_dummy_55_48_len 8
+#define reg_dummy_55_48_lsb 48
+#define xd_p_reg_dummy_63_56    0xA60F
+#define reg_dummy_63_56_pos 0
+#define reg_dummy_63_56_len 8
+#define reg_dummy_63_56_lsb 56
+#define xd_p_reg_dummy_71_64    0xA610
+#define reg_dummy_71_64_pos 0
+#define reg_dummy_71_64_len 8
+#define reg_dummy_71_64_lsb 64
+#define xd_p_reg_dummy_79_72    0xA611
+#define reg_dummy_79_72_pos 0
+#define reg_dummy_79_72_len 8
+#define reg_dummy_79_72_lsb 72
+#define xd_p_reg_dummy_87_80    0xA612
+#define reg_dummy_87_80_pos 0
+#define reg_dummy_87_80_len 8
+#define reg_dummy_87_80_lsb 80
+#define xd_p_reg_dummy_95_88    0xA613
+#define reg_dummy_95_88_pos 0
+#define reg_dummy_95_88_len 8
+#define reg_dummy_95_88_lsb 88
+#define xd_p_reg_dummy_103_96   0xA614
+#define reg_dummy_103_96_pos 0
+#define reg_dummy_103_96_len 8
+#define reg_dummy_103_96_lsb 96
+
+#define xd_p_reg_unplug_flag    0xA615
+#define reg_unplug_flag_pos 0
+#define reg_unplug_flag_len 1
+#define reg_unplug_flag_lsb 104
+
+#define xd_p_reg_api_dca_stes_request   0xA615
+#define reg_api_dca_stes_request_pos 1
+#define reg_api_dca_stes_request_len 1
+#define reg_api_dca_stes_request_lsb 0
+
+#define xd_p_reg_back_to_dca_flag       0xA615
+#define reg_back_to_dca_flag_pos 2
+#define reg_back_to_dca_flag_len 1
+#define reg_back_to_dca_flag_lsb 106
+
+#define xd_p_reg_api_retrain_request    0xA615
+#define reg_api_retrain_request_pos 3
+#define reg_api_retrain_request_len 1
+#define reg_api_retrain_request_lsb 0
+
+#define xd_p_reg_Dyn_Top_Try_flag       0xA615
+#define reg_Dyn_Top_Try_flag_pos 3
+#define reg_Dyn_Top_Try_flag_len 1
+#define reg_Dyn_Top_Try_flag_lsb 107
+
+#define xd_p_reg_API_retrain_freeze_flag        0xA615
+#define reg_API_retrain_freeze_flag_pos 4
+#define reg_API_retrain_freeze_flag_len 1
+#define reg_API_retrain_freeze_flag_lsb 108
+
+#define xd_p_reg_dummy_111_104  0xA615
+#define reg_dummy_111_104_pos 0
+#define reg_dummy_111_104_len 8
+#define reg_dummy_111_104_lsb 104
+#define xd_p_reg_dummy_119_112  0xA616
+#define reg_dummy_119_112_pos 0
+#define reg_dummy_119_112_len 8
+#define reg_dummy_119_112_lsb 112
+#define xd_p_reg_dummy_127_120  0xA617
+#define reg_dummy_127_120_pos 0
+#define reg_dummy_127_120_len 8
+#define reg_dummy_127_120_lsb 120
+#define xd_p_reg_dummy_135_128  0xA618
+#define reg_dummy_135_128_pos 0
+#define reg_dummy_135_128_len 8
+#define reg_dummy_135_128_lsb 128
+
+#define xd_p_reg_dummy_143_136  0xA619
+#define reg_dummy_143_136_pos 0
+#define reg_dummy_143_136_len 8
+#define reg_dummy_143_136_lsb 136
+
+#define xd_p_reg_CCIR_dis       0xA619
+#define reg_CCIR_dis_pos 0
+#define reg_CCIR_dis_len 1
+#define reg_CCIR_dis_lsb 0
+
+#define xd_p_reg_dummy_151_144  0xA61A
+#define reg_dummy_151_144_pos 0
+#define reg_dummy_151_144_len 8
+#define reg_dummy_151_144_lsb 144
+
+#define xd_p_reg_dummy_159_152  0xA61B
+#define reg_dummy_159_152_pos 0
+#define reg_dummy_159_152_len 8
+#define reg_dummy_159_152_lsb 152
+
+#define xd_p_reg_dummy_167_160  0xA61C
+#define reg_dummy_167_160_pos 0
+#define reg_dummy_167_160_len 8
+#define reg_dummy_167_160_lsb 160
+
+#define xd_p_reg_dummy_175_168  0xA61D
+#define reg_dummy_175_168_pos 0
+#define reg_dummy_175_168_len 8
+#define reg_dummy_175_168_lsb 168
+
+#define xd_p_reg_dummy_183_176  0xA61E
+#define reg_dummy_183_176_pos 0
+#define reg_dummy_183_176_len 8
+#define reg_dummy_183_176_lsb 176
+
+#define xd_p_reg_ofsm_read_rbc_en  0xA61E
+#define reg_ofsm_read_rbc_en_pos 2
+#define reg_ofsm_read_rbc_en_len 1
+#define reg_ofsm_read_rbc_en_lsb 0
+
+#define xd_p_reg_ce_filter_selection_dis  0xA61E
+#define reg_ce_filter_selection_dis_pos 1
+#define reg_ce_filter_selection_dis_len 1
+#define reg_ce_filter_selection_dis_lsb 0
+
+#define xd_p_reg_OFSM_version_control_7_0  0xA611
+#define reg_OFSM_version_control_7_0_pos 0
+#define reg_OFSM_version_control_7_0_len 8
+#define reg_OFSM_version_control_7_0_lsb 0
+
+#define xd_p_reg_OFSM_version_control_15_8  0xA61F
+#define reg_OFSM_version_control_15_8_pos 0
+#define reg_OFSM_version_control_15_8_len 8
+#define reg_OFSM_version_control_15_8_lsb 0
+
+#define xd_p_reg_OFSM_version_control_23_16  0xA620
+#define reg_OFSM_version_control_23_16_pos 0
+#define reg_OFSM_version_control_23_16_len 8
+#define reg_OFSM_version_control_23_16_lsb 0
+
+#define xd_p_reg_dummy_191_184  0xA61F
+#define reg_dummy_191_184_pos 0
+#define reg_dummy_191_184_len 8
+#define reg_dummy_191_184_lsb 184
+
+#define xd_p_reg_dummy_199_192  0xA620
+#define reg_dummy_199_192_pos 0
+#define reg_dummy_199_192_len 8
+#define reg_dummy_199_192_lsb 192
+
+#define xd_p_reg_ce_en  0xABC0
+#define reg_ce_en_pos 0
+#define reg_ce_en_len 1
+#define reg_ce_en_lsb 0
+#define xd_p_reg_ce_fctrl_en    0xABC0
+#define reg_ce_fctrl_en_pos 1
+#define reg_ce_fctrl_en_len 1
+#define reg_ce_fctrl_en_lsb 0
+#define xd_p_reg_ce_fste_tdi    0xABC0
+#define reg_ce_fste_tdi_pos 2
+#define reg_ce_fste_tdi_len 1
+#define reg_ce_fste_tdi_lsb 0
+#define xd_p_reg_ce_dynamic     0xABC0
+#define reg_ce_dynamic_pos 3
+#define reg_ce_dynamic_len 1
+#define reg_ce_dynamic_lsb 0
+#define xd_p_reg_ce_conf        0xABC0
+#define reg_ce_conf_pos 4
+#define reg_ce_conf_len 2
+#define reg_ce_conf_lsb 0
+#define xd_p_reg_ce_dyn12       0xABC0
+#define reg_ce_dyn12_pos 6
+#define reg_ce_dyn12_len 1
+#define reg_ce_dyn12_lsb 0
+#define xd_p_reg_ce_derot_en    0xABC0
+#define reg_ce_derot_en_pos 7
+#define reg_ce_derot_en_len 1
+#define reg_ce_derot_en_lsb 0
+#define xd_p_reg_ce_dynamic_th_7_0      0xABC1
+#define reg_ce_dynamic_th_7_0_pos 0
+#define reg_ce_dynamic_th_7_0_len 8
+#define reg_ce_dynamic_th_7_0_lsb 0
+#define xd_p_reg_ce_dynamic_th_15_8     0xABC2
+#define reg_ce_dynamic_th_15_8_pos 0
+#define reg_ce_dynamic_th_15_8_len 8
+#define reg_ce_dynamic_th_15_8_lsb 8
+#define xd_p_reg_ce_s1  0xABC3
+#define reg_ce_s1_pos 0
+#define reg_ce_s1_len 5
+#define reg_ce_s1_lsb 0
+#define xd_p_reg_ce_var_forced_value    0xABC3
+#define reg_ce_var_forced_value_pos 5
+#define reg_ce_var_forced_value_len 3
+#define reg_ce_var_forced_value_lsb 0
+#define xd_p_reg_ce_data_im_7_0 0xABC4
+#define reg_ce_data_im_7_0_pos 0
+#define reg_ce_data_im_7_0_len 8
+#define reg_ce_data_im_7_0_lsb 0
+#define xd_p_reg_ce_data_im_8   0xABC5
+#define reg_ce_data_im_8_pos 0
+#define reg_ce_data_im_8_len 1
+#define reg_ce_data_im_8_lsb 0
+#define xd_p_reg_ce_data_re_6_0 0xABC5
+#define reg_ce_data_re_6_0_pos 1
+#define reg_ce_data_re_6_0_len 7
+#define reg_ce_data_re_6_0_lsb 0
+#define xd_p_reg_ce_data_re_8_7 0xABC6
+#define reg_ce_data_re_8_7_pos 0
+#define reg_ce_data_re_8_7_len 2
+#define reg_ce_data_re_8_7_lsb 7
+#define xd_p_reg_ce_tone_5_0    0xABC6
+#define reg_ce_tone_5_0_pos 2
+#define reg_ce_tone_5_0_len 6
+#define reg_ce_tone_5_0_lsb 0
+#define xd_p_reg_ce_tone_12_6   0xABC7
+#define reg_ce_tone_12_6_pos 0
+#define reg_ce_tone_12_6_len 7
+#define reg_ce_tone_12_6_lsb 6
+#define xd_p_reg_ce_centroid_drift_th   0xABC8
+#define reg_ce_centroid_drift_th_pos 0
+#define reg_ce_centroid_drift_th_len 8
+#define reg_ce_centroid_drift_th_lsb 0
+#define xd_p_reg_ce_centroid_count_max  0xABC9
+#define reg_ce_centroid_count_max_pos 0
+#define reg_ce_centroid_count_max_len 4
+#define reg_ce_centroid_count_max_lsb 0
+#define xd_p_reg_ce_centroid_bias_inc_7_0       0xABCA
+#define reg_ce_centroid_bias_inc_7_0_pos 0
+#define reg_ce_centroid_bias_inc_7_0_len 8
+#define reg_ce_centroid_bias_inc_7_0_lsb 0
+#define xd_p_reg_ce_centroid_bias_inc_8 0xABCB
+#define reg_ce_centroid_bias_inc_8_pos 0
+#define reg_ce_centroid_bias_inc_8_len 1
+#define reg_ce_centroid_bias_inc_8_lsb 0
+#define xd_p_reg_ce_var_th0_7_0 0xABCC
+#define reg_ce_var_th0_7_0_pos 0
+#define reg_ce_var_th0_7_0_len 8
+#define reg_ce_var_th0_7_0_lsb 0
+#define xd_p_reg_ce_var_th0_15_8        0xABCD
+#define reg_ce_var_th0_15_8_pos 0
+#define reg_ce_var_th0_15_8_len 8
+#define reg_ce_var_th0_15_8_lsb 8
+#define xd_p_reg_ce_var_th1_7_0 0xABCE
+#define reg_ce_var_th1_7_0_pos 0
+#define reg_ce_var_th1_7_0_len 8
+#define reg_ce_var_th1_7_0_lsb 0
+#define xd_p_reg_ce_var_th1_15_8        0xABCF
+#define reg_ce_var_th1_15_8_pos 0
+#define reg_ce_var_th1_15_8_len 8
+#define reg_ce_var_th1_15_8_lsb 8
+#define xd_p_reg_ce_var_th2_7_0 0xABD0
+#define reg_ce_var_th2_7_0_pos 0
+#define reg_ce_var_th2_7_0_len 8
+#define reg_ce_var_th2_7_0_lsb 0
+#define xd_p_reg_ce_var_th2_15_8        0xABD1
+#define reg_ce_var_th2_15_8_pos 0
+#define reg_ce_var_th2_15_8_len 8
+#define reg_ce_var_th2_15_8_lsb 8
+#define xd_p_reg_ce_var_th3_7_0 0xABD2
+#define reg_ce_var_th3_7_0_pos 0
+#define reg_ce_var_th3_7_0_len 8
+#define reg_ce_var_th3_7_0_lsb 0
+#define xd_p_reg_ce_var_th3_15_8        0xABD3
+#define reg_ce_var_th3_15_8_pos 0
+#define reg_ce_var_th3_15_8_len 8
+#define reg_ce_var_th3_15_8_lsb 8
+#define xd_p_reg_ce_var_th4_7_0 0xABD4
+#define reg_ce_var_th4_7_0_pos 0
+#define reg_ce_var_th4_7_0_len 8
+#define reg_ce_var_th4_7_0_lsb 0
+#define xd_p_reg_ce_var_th4_15_8        0xABD5
+#define reg_ce_var_th4_15_8_pos 0
+#define reg_ce_var_th4_15_8_len 8
+#define reg_ce_var_th4_15_8_lsb 8
+#define xd_p_reg_ce_var_th5_7_0 0xABD6
+#define reg_ce_var_th5_7_0_pos 0
+#define reg_ce_var_th5_7_0_len 8
+#define reg_ce_var_th5_7_0_lsb 0
+#define xd_p_reg_ce_var_th5_15_8        0xABD7
+#define reg_ce_var_th5_15_8_pos 0
+#define reg_ce_var_th5_15_8_len 8
+#define reg_ce_var_th5_15_8_lsb 8
+#define xd_p_reg_ce_var_th6_7_0 0xABD8
+#define reg_ce_var_th6_7_0_pos 0
+#define reg_ce_var_th6_7_0_len 8
+#define reg_ce_var_th6_7_0_lsb 0
+#define xd_p_reg_ce_var_th6_15_8        0xABD9
+#define reg_ce_var_th6_15_8_pos 0
+#define reg_ce_var_th6_15_8_len 8
+#define reg_ce_var_th6_15_8_lsb 8
+#define xd_p_reg_ce_fctrl_reset 0xABDA
+#define reg_ce_fctrl_reset_pos 0
+#define reg_ce_fctrl_reset_len 1
+#define reg_ce_fctrl_reset_lsb 0
+#define xd_p_reg_ce_cent_auto_clr_en    0xABDA
+#define reg_ce_cent_auto_clr_en_pos 1
+#define reg_ce_cent_auto_clr_en_len 1
+#define reg_ce_cent_auto_clr_en_lsb 0
+#define xd_p_reg_ce_fctrl_auto_reset_en 0xABDA
+#define reg_ce_fctrl_auto_reset_en_pos 2
+#define reg_ce_fctrl_auto_reset_en_len 1
+#define reg_ce_fctrl_auto_reset_en_lsb 0
+#define xd_p_reg_ce_var_forced_en       0xABDA
+#define reg_ce_var_forced_en_pos 3
+#define reg_ce_var_forced_en_len 1
+#define reg_ce_var_forced_en_lsb 0
+#define xd_p_reg_ce_cent_forced_en      0xABDA
+#define reg_ce_cent_forced_en_pos 4
+#define reg_ce_cent_forced_en_len 1
+#define reg_ce_cent_forced_en_lsb 0
+#define xd_p_reg_ce_var_max     0xABDA
+#define reg_ce_var_max_pos 5
+#define reg_ce_var_max_len 3
+#define reg_ce_var_max_lsb 0
+#define xd_p_reg_ce_cent_forced_value_7_0       0xABDB
+#define reg_ce_cent_forced_value_7_0_pos 0
+#define reg_ce_cent_forced_value_7_0_len 8
+#define reg_ce_cent_forced_value_7_0_lsb 0
+#define xd_p_reg_ce_cent_forced_value_11_8      0xABDC
+#define reg_ce_cent_forced_value_11_8_pos 0
+#define reg_ce_cent_forced_value_11_8_len 4
+#define reg_ce_cent_forced_value_11_8_lsb 8
+#define xd_p_reg_ce_fctrl_rd    0xABDD
+#define reg_ce_fctrl_rd_pos 0
+#define reg_ce_fctrl_rd_len 1
+#define reg_ce_fctrl_rd_lsb 0
+#define xd_p_reg_ce_centroid_max_6_0    0xABDD
+#define reg_ce_centroid_max_6_0_pos 1
+#define reg_ce_centroid_max_6_0_len 7
+#define reg_ce_centroid_max_6_0_lsb 0
+#define xd_p_reg_ce_centroid_max_11_7   0xABDE
+#define reg_ce_centroid_max_11_7_pos 0
+#define reg_ce_centroid_max_11_7_len 5
+#define reg_ce_centroid_max_11_7_lsb 7
+#define xd_p_reg_ce_var 0xABDF
+#define reg_ce_var_pos 0
+#define reg_ce_var_len 3
+#define reg_ce_var_lsb 0
+#define xd_p_reg_ce_fctrl_rdy   0xABDF
+#define reg_ce_fctrl_rdy_pos 3
+#define reg_ce_fctrl_rdy_len 1
+#define reg_ce_fctrl_rdy_lsb 0
+#define xd_p_reg_ce_centroid_out_3_0    0xABDF
+#define reg_ce_centroid_out_3_0_pos 4
+#define reg_ce_centroid_out_3_0_len 4
+#define reg_ce_centroid_out_3_0_lsb 0
+#define xd_p_reg_ce_centroid_out_11_4   0xABE0
+#define reg_ce_centroid_out_11_4_pos 0
+#define reg_ce_centroid_out_11_4_len 8
+#define reg_ce_centroid_out_11_4_lsb 4
+#define xd_p_reg_ce_bias_7_0    0xABE1
+#define reg_ce_bias_7_0_pos 0
+#define reg_ce_bias_7_0_len 8
+#define reg_ce_bias_7_0_lsb 0
+#define xd_p_reg_ce_bias_11_8   0xABE2
+#define reg_ce_bias_11_8_pos 0
+#define reg_ce_bias_11_8_len 4
+#define reg_ce_bias_11_8_lsb 8
+#define xd_p_reg_ce_m1_3_0      0xABE2
+#define reg_ce_m1_3_0_pos 4
+#define reg_ce_m1_3_0_len 4
+#define reg_ce_m1_3_0_lsb 0
+#define xd_p_reg_ce_m1_11_4     0xABE3
+#define reg_ce_m1_11_4_pos 0
+#define reg_ce_m1_11_4_len 8
+#define reg_ce_m1_11_4_lsb 4
+#define xd_p_reg_ce_rh0_7_0     0xABE4
+#define reg_ce_rh0_7_0_pos 0
+#define reg_ce_rh0_7_0_len 8
+#define reg_ce_rh0_7_0_lsb 0
+#define xd_p_reg_ce_rh0_15_8    0xABE5
+#define reg_ce_rh0_15_8_pos 0
+#define reg_ce_rh0_15_8_len 8
+#define reg_ce_rh0_15_8_lsb 8
+#define xd_p_reg_ce_rh0_23_16   0xABE6
+#define reg_ce_rh0_23_16_pos 0
+#define reg_ce_rh0_23_16_len 8
+#define reg_ce_rh0_23_16_lsb 16
+#define xd_p_reg_ce_rh0_31_24   0xABE7
+#define reg_ce_rh0_31_24_pos 0
+#define reg_ce_rh0_31_24_len 8
+#define reg_ce_rh0_31_24_lsb 24
+#define xd_p_reg_ce_rh3_real_7_0        0xABE8
+#define reg_ce_rh3_real_7_0_pos 0
+#define reg_ce_rh3_real_7_0_len 8
+#define reg_ce_rh3_real_7_0_lsb 0
+#define xd_p_reg_ce_rh3_real_15_8       0xABE9
+#define reg_ce_rh3_real_15_8_pos 0
+#define reg_ce_rh3_real_15_8_len 8
+#define reg_ce_rh3_real_15_8_lsb 8
+#define xd_p_reg_ce_rh3_real_23_16      0xABEA
+#define reg_ce_rh3_real_23_16_pos 0
+#define reg_ce_rh3_real_23_16_len 8
+#define reg_ce_rh3_real_23_16_lsb 16
+#define xd_p_reg_ce_rh3_real_31_24      0xABEB
+#define reg_ce_rh3_real_31_24_pos 0
+#define reg_ce_rh3_real_31_24_len 8
+#define reg_ce_rh3_real_31_24_lsb 24
+#define xd_p_reg_ce_rh3_imag_7_0        0xABEC
+#define reg_ce_rh3_imag_7_0_pos 0
+#define reg_ce_rh3_imag_7_0_len 8
+#define reg_ce_rh3_imag_7_0_lsb 0
+#define xd_p_reg_ce_rh3_imag_15_8       0xABED
+#define reg_ce_rh3_imag_15_8_pos 0
+#define reg_ce_rh3_imag_15_8_len 8
+#define reg_ce_rh3_imag_15_8_lsb 8
+#define xd_p_reg_ce_rh3_imag_23_16      0xABEE
+#define reg_ce_rh3_imag_23_16_pos 0
+#define reg_ce_rh3_imag_23_16_len 8
+#define reg_ce_rh3_imag_23_16_lsb 16
+#define xd_p_reg_ce_rh3_imag_31_24      0xABEF
+#define reg_ce_rh3_imag_31_24_pos 0
+#define reg_ce_rh3_imag_31_24_len 8
+#define reg_ce_rh3_imag_31_24_lsb 24
+#define xd_p_reg_feq_fix_eh2_7_0        0xABF0
+#define reg_feq_fix_eh2_7_0_pos 0
+#define reg_feq_fix_eh2_7_0_len 8
+#define reg_feq_fix_eh2_7_0_lsb 0
+#define xd_p_reg_feq_fix_eh2_15_8       0xABF1
+#define reg_feq_fix_eh2_15_8_pos 0
+#define reg_feq_fix_eh2_15_8_len 8
+#define reg_feq_fix_eh2_15_8_lsb 8
+#define xd_p_reg_feq_fix_eh2_23_16      0xABF2
+#define reg_feq_fix_eh2_23_16_pos 0
+#define reg_feq_fix_eh2_23_16_len 8
+#define reg_feq_fix_eh2_23_16_lsb 16
+#define xd_p_reg_feq_fix_eh2_31_24      0xABF3
+#define reg_feq_fix_eh2_31_24_pos 0
+#define reg_feq_fix_eh2_31_24_len 8
+#define reg_feq_fix_eh2_31_24_lsb 24
+#define xd_p_reg_ce_m2_central_7_0      0xABF4
+#define reg_ce_m2_central_7_0_pos 0
+#define reg_ce_m2_central_7_0_len 8
+#define reg_ce_m2_central_7_0_lsb 0
+#define xd_p_reg_ce_m2_central_15_8     0xABF5
+#define reg_ce_m2_central_15_8_pos 0
+#define reg_ce_m2_central_15_8_len 8
+#define reg_ce_m2_central_15_8_lsb 8
+#define xd_p_reg_ce_fftshift    0xABF6
+#define reg_ce_fftshift_pos 0
+#define reg_ce_fftshift_len 4
+#define reg_ce_fftshift_lsb 0
+#define xd_p_reg_ce_fftshift1   0xABF6
+#define reg_ce_fftshift1_pos 4
+#define reg_ce_fftshift1_len 4
+#define reg_ce_fftshift1_lsb 0
+#define xd_p_reg_ce_fftshift2   0xABF7
+#define reg_ce_fftshift2_pos 0
+#define reg_ce_fftshift2_len 4
+#define reg_ce_fftshift2_lsb 0
+#define xd_p_reg_ce_top_mobile  0xABF7
+#define reg_ce_top_mobile_pos 4
+#define reg_ce_top_mobile_len 1
+#define reg_ce_top_mobile_lsb 0
+#define xd_p_reg_strong_sginal_detected 0xA2BC
+#define reg_strong_sginal_detected_pos 2
+#define reg_strong_sginal_detected_len 1
+#define reg_strong_sginal_detected_lsb 0
+
+#define XD_MP2IF_BASE                           0xB000
+#define XD_MP2IF_CSR                        (0x00 + XD_MP2IF_BASE)
+#define XD_MP2IF_DMX_CTRL                       (0x03 + XD_MP2IF_BASE)
+#define XD_MP2IF_PID_IDX                        (0x04 + XD_MP2IF_BASE)
+#define XD_MP2IF_PID_DATA_L                     (0x05 + XD_MP2IF_BASE)
+#define XD_MP2IF_PID_DATA_H                     (0x06 + XD_MP2IF_BASE)
+#define XD_MP2IF_MISC                       (0x07 + XD_MP2IF_BASE)
+
+extern struct dvb_frontend *af9005_fe_attach(struct dvb_usb_device *d);
+extern int af9005_read_ofdm_register(struct dvb_usb_device *d, u16 reg,
+                                     u8 * value);
+extern int af9005_read_ofdm_registers(struct dvb_usb_device *d, u16 reg,
+                                      u8 * values, int len);
+extern int af9005_write_ofdm_register(struct dvb_usb_device *d, u16 reg,
+                                      u8 value);
+extern int af9005_write_ofdm_registers(struct dvb_usb_device *d, u16 reg,
+                                       u8 * values, int len);
+extern int af9005_read_tuner_registers(struct dvb_usb_device *d, u16 reg,
+                                       u8 addr, u8 * values, int len);
+extern int af9005_write_tuner_registers(struct dvb_usb_device *d, u16 reg,
+                                        u8 * values, int len);
+extern int af9005_read_register_bits(struct dvb_usb_device *d, u16 reg,
+                                     u8 pos, u8 len, u8 * value);
+extern int af9005_write_register_bits(struct dvb_usb_device *d, u16 reg,
+                                      u8 pos, u8 len, u8 value);
+extern int af9005_send_command(struct dvb_usb_device *d, u8 command,
+                               u8 * wbuf, int wlen, u8 * rbuf, int rlen);
+extern int af9005_read_eeprom(struct dvb_usb_device *d, u8 address,
+                              u8 * values, int len);
+extern int af9005_tuner_attach(struct dvb_usb_adapter *adap);
+extern int af9005_led_control(struct dvb_usb_device *d, int onoff);
+
+extern u8 regmask[8];
+
+/* remote control decoder */
+extern int af9005_rc_decode(struct dvb_usb_device *d, u8 * data, int len,
+                            u32 * event, int *state);
+extern struct rc_map_table rc_map_af9005_table[];
+extern int rc_map_af9005_table_size;
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/af9015.c b/drivers/media/dvb/dvb-usb/af9015.c
new file mode 100644
index 00000000000..d7ad05fc383
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/af9015.c
@@ -0,0 +1,1718 @@
+/*
+ * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
+ *
+ * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
+ *
+ * Thanks to Afatech who kindly provided information.
+ *
+ *    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/hash.h>
+#include <linux/slab.h>
+
+#include "af9015.h"
+#include "af9013.h"
+#include "mt2060.h"
+#include "qt1010.h"
+#include "tda18271.h"
+#include "mxl5005s.h"
+#include "mc44s803.h"
+#include "tda18218.h"
+#include "mxl5007t.h"
+
+static int dvb_usb_af9015_debug;
+module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
+static int dvb_usb_af9015_remote;
+module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
+MODULE_PARM_DESC(remote, "select remote");
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static DEFINE_MUTEX(af9015_usb_mutex);
+
+static struct af9015_config af9015_config;
+static struct dvb_usb_device_properties af9015_properties[3];
+static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
+
+static struct af9013_config af9015_af9013_config[] = {
+        {
+                .demod_address = AF9015_I2C_DEMOD,
+                .output_mode = AF9013_OUTPUT_MODE_USB,
+                .api_version = { 0, 1, 9, 0 },
+                .gpio[0] = AF9013_GPIO_HI,
+                .gpio[3] = AF9013_GPIO_TUNER_ON,
+
+        }, {
+                .output_mode = AF9013_OUTPUT_MODE_SERIAL,
+                .api_version = { 0, 1, 9, 0 },
+                .gpio[0] = AF9013_GPIO_TUNER_ON,
+                .gpio[1] = AF9013_GPIO_LO,
+        }
+};
+
+static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
+{
+#define BUF_LEN 63
+#define REQ_HDR_LEN 8 /* send header size */
+#define ACK_HDR_LEN 2 /* rece header size */
+        int act_len, ret;
+        u8 buf[BUF_LEN];
+        u8 write = 1;
+        u8 msg_len = REQ_HDR_LEN;
+        static u8 seq; /* packet sequence number */
+
+        if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
+                return -EAGAIN;
+
+        buf[0] = req->cmd;
+        buf[1] = seq++;
+        buf[2] = req->i2c_addr;
+        buf[3] = req->addr >> 8;
+        buf[4] = req->addr & 0xff;
+        buf[5] = req->mbox;
+        buf[6] = req->addr_len;
+        buf[7] = req->data_len;
+
+        switch (req->cmd) {
+        case GET_CONFIG:
+        case READ_MEMORY:
+        case RECONNECT_USB:
+                write = 0;
+                break;
+        case READ_I2C:
+                write = 0;
+                buf[2] |= 0x01; /* set I2C direction */
+        case WRITE_I2C:
+                buf[0] = READ_WRITE_I2C;
+                break;
+        case WRITE_MEMORY:
+                if (((req->addr & 0xff00) == 0xff00) ||
+                    ((req->addr & 0xff00) == 0xae00))
+                        buf[0] = WRITE_VIRTUAL_MEMORY;
+        case WRITE_VIRTUAL_MEMORY:
+        case COPY_FIRMWARE:
+        case DOWNLOAD_FIRMWARE:
+        case BOOT:
+                break;
+        default:
+                err("unknown command:%d", req->cmd);
+                ret = -1;
+                goto error_unlock;
+        }
+
+        /* buffer overflow check */
+        if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
+                (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
+                err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
+                ret = -EINVAL;
+                goto error_unlock;
+        }
+
+        /* write requested */
+        if (write) {
+                memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
+                msg_len += req->data_len;
+        }
+
+        deb_xfer(">>> ");
+        debug_dump(buf, msg_len, deb_xfer);
+
+        /* send req */
+        ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
+                &act_len, AF9015_USB_TIMEOUT);
+        if (ret)
+                err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
+        else
+                if (act_len != msg_len)
+                        ret = -1; /* all data is not send */
+        if (ret)
+                goto error_unlock;
+
+        /* no ack for those packets */
+        if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
+                goto exit_unlock;
+
+        /* write receives seq + status = 2 bytes
+           read receives seq + status + data = 2 + N bytes */
+        msg_len = ACK_HDR_LEN;
+        if (!write)
+                msg_len += req->data_len;
+
+        ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
+                &act_len, AF9015_USB_TIMEOUT);
+        if (ret) {
+                err("recv bulk message failed:%d", ret);
+                ret = -1;
+                goto error_unlock;
+        }
+
+        deb_xfer("<<< ");
+        debug_dump(buf, act_len, deb_xfer);
+
+        /* check status */
+        if (buf[1]) {
+                err("command failed:%d", buf[1]);
+                ret = -1;
+                goto error_unlock;
+        }
+
+        /* read request, copy returned data to return buf */
+        if (!write)
+                memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
+
+error_unlock:
+exit_unlock:
+        mutex_unlock(&af9015_usb_mutex);
+
+        return ret;
+}
+
+static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
+{
+        return af9015_rw_udev(d->udev, req);
+}
+
+static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
+        u8 len)
+{
+        struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
+                val};
+        return af9015_ctrl_msg(d, &req);
+}
+
+static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
+{
+        return af9015_write_regs(d, addr, &val, 1);
+}
+
+static int af9015_read_regs(struct dvb_usb_device *d, u16 addr, u8 *val, u8 len)
+{
+        struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
+                val};
+        return af9015_ctrl_msg(d, &req);
+}
+
+static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
+{
+        return af9015_read_regs(d, addr, val, 1);
+}
+
+static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
+        u8 val)
+{
+        struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
+
+        if (addr == af9015_af9013_config[0].demod_address ||
+            addr == af9015_af9013_config[1].demod_address)
+                req.addr_len = 3;
+
+        return af9015_ctrl_msg(d, &req);
+}
+
+static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
+        u8 *val)
+{
+        struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
+
+        if (addr == af9015_af9013_config[0].demod_address ||
+            addr == af9015_af9013_config[1].demod_address)
+                req.addr_len = 3;
+
+        return af9015_ctrl_msg(d, &req);
+}
+
+static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+        int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int ret = 0, i = 0;
+        u16 addr;
+        u8 uninitialized_var(mbox), addr_len;
+        struct req_t req;
+
+/* TODO: implement bus lock
+
+The bus lock is needed because there is two tuners both using same I2C-address.
+Due to that the only way to select correct tuner is use demodulator I2C-gate.
+
+................................................
+. AF9015 includes integrated AF9013 demodulator.
+. ____________                   ____________  .                ____________
+.|     uC     |                 |   demod    | .               |    tuner   |
+.|------------|                 |------------| .               |------------|
+.|   AF9015   |                 |  AF9013/5  | .               |   MXL5003  |
+.|            |--+----I2C-------|-----/ -----|-.-----I2C-------|            |
+.|            |  |              | addr 0x38  | .               |  addr 0xc6 |
+.|____________|  |              |____________| .               |____________|
+.................|..............................
+                 |               ____________                   ____________
+                 |              |   demod    |                 |    tuner   |
+                 |              |------------|                 |------------|
+                 |              |   AF9013   |                 |   MXL5003  |
+                 +----I2C-------|-----/ -----|-------I2C-------|            |
+                                | addr 0x3a  |                 |  addr 0xc6 |
+                                |____________|                 |____________|
+*/
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        while (i < num) {
+                if (msg[i].addr == af9015_af9013_config[0].demod_address ||
+                    msg[i].addr == af9015_af9013_config[1].demod_address) {
+                        addr = msg[i].buf[0] << 8;
+                        addr += msg[i].buf[1];
+                        mbox = msg[i].buf[2];
+                        addr_len = 3;
+                } else {
+                        addr = msg[i].buf[0];
+                        addr_len = 1;
+                        /* mbox is don't care in that case */
+                }
+
+                if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
+                        if (msg[i].len > 3 || msg[i+1].len > 61) {
+                                ret = -EOPNOTSUPP;
+                                goto error;
+                        }
+                        if (msg[i].addr ==
+                                af9015_af9013_config[0].demod_address)
+                                req.cmd = READ_MEMORY;
+                        else
+                                req.cmd = READ_I2C;
+                        req.i2c_addr = msg[i].addr;
+                        req.addr = addr;
+                        req.mbox = mbox;
+                        req.addr_len = addr_len;
+                        req.data_len = msg[i+1].len;
+                        req.data = &msg[i+1].buf[0];
+                        ret = af9015_ctrl_msg(d, &req);
+                        i += 2;
+                } else if (msg[i].flags & I2C_M_RD) {
+                        if (msg[i].len > 61) {
+                                ret = -EOPNOTSUPP;
+                                goto error;
+                        }
+                        if (msg[i].addr ==
+                                af9015_af9013_config[0].demod_address) {
+                                ret = -EINVAL;
+                                goto error;
+                        }
+                        req.cmd = READ_I2C;
+                        req.i2c_addr = msg[i].addr;
+                        req.addr = addr;
+                        req.mbox = mbox;
+                        req.addr_len = addr_len;
+                        req.data_len = msg[i].len;
+                        req.data = &msg[i].buf[0];
+                        ret = af9015_ctrl_msg(d, &req);
+                        i += 1;
+                } else {
+                        if (msg[i].len > 21) {
+                                ret = -EOPNOTSUPP;
+                                goto error;
+                        }
+                        if (msg[i].addr ==
+                                af9015_af9013_config[0].demod_address)
+                                req.cmd = WRITE_MEMORY;
+                        else
+                                req.cmd = WRITE_I2C;
+                        req.i2c_addr = msg[i].addr;
+                        req.addr = addr;
+                        req.mbox = mbox;
+                        req.addr_len = addr_len;
+                        req.data_len = msg[i].len-addr_len;
+                        req.data = &msg[i].buf[addr_len];
+                        ret = af9015_ctrl_msg(d, &req);
+                        i += 1;
+                }
+                if (ret)
+                        goto error;
+
+        }
+        ret = i;
+
+error:
+        mutex_unlock(&d->i2c_mutex);
+
+        return ret;
+}
+
+static u32 af9015_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm af9015_i2c_algo = {
+        .master_xfer = af9015_i2c_xfer,
+        .functionality = af9015_i2c_func,
+};
+
+static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
+{
+        int ret;
+        u8 val, mask = 0x01;
+
+        ret = af9015_read_reg(d, addr, &val);
+        if (ret)
+                return ret;
+
+        mask <<= bit;
+        if (op) {
+                /* set bit */
+                val |= mask;
+        } else {
+                /* clear bit */
+                mask ^= 0xff;
+                val &= mask;
+        }
+
+        return af9015_write_reg(d, addr, val);
+}
+
+static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
+{
+        return af9015_do_reg_bit(d, addr, bit, 1);
+}
+
+static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
+{
+        return af9015_do_reg_bit(d, addr, bit, 0);
+}
+
+static int af9015_init_endpoint(struct dvb_usb_device *d)
+{
+        int ret;
+        u16 frame_size;
+        u8  packet_size;
+        deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
+
+        /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
+           We use smaller - about 1/4 from the original, 5 and 87. */
+#define TS_PACKET_SIZE            188
+
+#define TS_USB20_PACKET_COUNT      87
+#define TS_USB20_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
+
+#define TS_USB11_PACKET_COUNT       5
+#define TS_USB11_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
+
+#define TS_USB20_MAX_PACKET_SIZE  512
+#define TS_USB11_MAX_PACKET_SIZE   64
+
+        if (d->udev->speed == USB_SPEED_FULL) {
+                frame_size = TS_USB11_FRAME_SIZE/4;
+                packet_size = TS_USB11_MAX_PACKET_SIZE/4;
+        } else {
+                frame_size = TS_USB20_FRAME_SIZE/4;
+                packet_size = TS_USB20_MAX_PACKET_SIZE/4;
+        }
+
+        ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
+        if (ret)
+                goto error;
+        ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
+        if (ret)
+                goto error;
+        ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
+        if (ret)
+                goto error;
+        ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
+        if (ret)
+                goto error;
+        ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
+        if (ret)
+                goto error;
+        if (af9015_config.dual_mode) {
+                ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
+                if (ret)
+                        goto error;
+        }
+        ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
+        if (ret)
+                goto error;
+        if (af9015_config.dual_mode) {
+                ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
+                if (ret)
+                        goto error;
+        }
+        /* EP4 xfer length */
+        ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
+        if (ret)
+                goto error;
+        ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
+        if (ret)
+                goto error;
+        /* EP5 xfer length */
+        ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
+        if (ret)
+                goto error;
+        ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
+        if (ret)
+                goto error;
+        ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
+        if (ret)
+                goto error;
+        ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
+        if (ret)
+                goto error;
+        ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
+        if (ret)
+                goto error;
+        if (af9015_config.dual_mode) {
+                ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
+                if (ret)
+                        goto error;
+        }
+
+        /* enable / disable mp2if2 */
+        if (af9015_config.dual_mode)
+                ret = af9015_set_reg_bit(d, 0xd50b, 0);
+        else
+                ret = af9015_clear_reg_bit(d, 0xd50b, 0);
+
+error:
+        if (ret)
+                err("endpoint init failed:%d", ret);
+        return ret;
+}
+
+static int af9015_copy_firmware(struct dvb_usb_device *d)
+{
+        int ret;
+        u8 fw_params[4];
+        u8 val, i;
+        struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
+                fw_params };
+        deb_info("%s:\n", __func__);
+
+        fw_params[0] = af9015_config.firmware_size >> 8;
+        fw_params[1] = af9015_config.firmware_size & 0xff;
+        fw_params[2] = af9015_config.firmware_checksum >> 8;
+        fw_params[3] = af9015_config.firmware_checksum & 0xff;
+
+        /* wait 2nd demodulator ready */
+        msleep(100);
+
+        ret = af9015_read_reg_i2c(d,
+                af9015_af9013_config[1].demod_address, 0x98be, &val);
+        if (ret)
+                goto error;
+        else
+                deb_info("%s: firmware status:%02x\n", __func__, val);
+
+        if (val == 0x0c) /* fw is running, no need for download */
+                goto exit;
+
+        /* set I2C master clock to fast (to speed up firmware copy) */
+        ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
+        if (ret)
+                goto error;
+
+        msleep(50);
+
+        /* copy firmware */
+        ret = af9015_ctrl_msg(d, &req);
+        if (ret)
+                err("firmware copy cmd failed:%d", ret);
+        deb_info("%s: firmware copy done\n", __func__);
+
+        /* set I2C master clock back to normal */
+        ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
+        if (ret)
+                goto error;
+
+        /* request boot firmware */
+        ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].demod_address,
+                0xe205, 1);
+        deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
+        if (ret)
+                goto error;
+
+        for (i = 0; i < 15; i++) {
+                msleep(100);
+
+                /* check firmware status */
+                ret = af9015_read_reg_i2c(d,
+                        af9015_af9013_config[1].demod_address, 0x98be, &val);
+                deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
+                        __func__, ret, val);
+                if (ret)
+                        goto error;
+
+                if (val == 0x0c || val == 0x04) /* success or fail */
+                        break;
+        }
+
+        if (val == 0x04) {
+                err("firmware did not run");
+                ret = -1;
+        } else if (val != 0x0c) {
+                err("firmware boot timeout");
+                ret = -1;
+        }
+
+error:
+exit:
+        return ret;
+}
+
+/* hash (and dump) eeprom */
+static int af9015_eeprom_hash(struct usb_device *udev)
+{
+        static const unsigned int eeprom_size = 256;
+        unsigned int reg;
+        int ret;
+        u8 val, *eeprom;
+        struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
+
+        eeprom = kmalloc(eeprom_size, GFP_KERNEL);
+        if (eeprom == NULL)
+                return -ENOMEM;
+
+        for (reg = 0; reg < eeprom_size; reg++) {
+                req.addr = reg;
+                ret = af9015_rw_udev(udev, &req);
+                if (ret)
+                        goto free;
+                eeprom[reg] = val;
+        }
+
+        if (dvb_usb_af9015_debug & 0x01)
+                print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, eeprom,
+                                eeprom_size);
+
+        BUG_ON(eeprom_size % 4);
+
+        af9015_config.eeprom_sum = 0;
+        for (reg = 0; reg < eeprom_size / sizeof(u32); reg++) {
+                af9015_config.eeprom_sum *= GOLDEN_RATIO_PRIME_32;
+                af9015_config.eeprom_sum += le32_to_cpu(((u32 *)eeprom)[reg]);
+        }
+
+        deb_info("%s: eeprom sum=%.8x\n", __func__, af9015_config.eeprom_sum);
+
+        ret = 0;
+free:
+        kfree(eeprom);
+        return ret;
+}
+
+static int af9015_init(struct dvb_usb_device *d)
+{
+        int ret;
+        deb_info("%s:\n", __func__);
+
+        /* init RC canary */
+        ret = af9015_write_reg(d, 0x98e9, 0xff);
+        if (ret)
+                goto error;
+
+        ret = af9015_init_endpoint(d);
+        if (ret)
+                goto error;
+
+error:
+        return ret;
+}
+
+static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        int ret;
+        deb_info("%s: onoff:%d\n", __func__, onoff);
+
+        if (onoff)
+                ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
+        else
+                ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
+
+        return ret;
+}
+
+static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
+        int onoff)
+{
+        int ret;
+        u8 idx;
+
+        deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
+                __func__, index, pid, onoff);
+
+        ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
+        if (ret)
+                goto error;
+
+        ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
+        if (ret)
+                goto error;
+
+        idx = ((index & 0x1f) | (1 << 5));
+        ret = af9015_write_reg(adap->dev, 0xd504, idx);
+
+error:
+        return ret;
+}
+
+static int af9015_download_firmware(struct usb_device *udev,
+        const struct firmware *fw)
+{
+        int i, len, remaining, ret;
+        struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
+        u16 checksum = 0;
+
+        deb_info("%s:\n", __func__);
+
+        /* calc checksum */
+        for (i = 0; i < fw->size; i++)
+                checksum += fw->data[i];
+
+        af9015_config.firmware_size = fw->size;
+        af9015_config.firmware_checksum = checksum;
+
+        #define FW_ADDR 0x5100 /* firmware start address */
+        #define LEN_MAX 55 /* max packet size */
+        for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) {
+                len = remaining;
+                if (len > LEN_MAX)
+                        len = LEN_MAX;
+
+                req.data_len = len;
+                req.data = (u8 *) &fw->data[fw->size - remaining];
+                req.addr = FW_ADDR + fw->size - remaining;
+
+                ret = af9015_rw_udev(udev, &req);
+                if (ret) {
+                        err("firmware download failed:%d", ret);
+                        goto error;
+                }
+        }
+
+        /* firmware loaded, request boot */
+        req.cmd = BOOT;
+        ret = af9015_rw_udev(udev, &req);
+        if (ret) {
+                err("firmware boot failed:%d", ret);
+                goto error;
+        }
+
+error:
+        return ret;
+}
+
+struct af9015_rc_setup {
+        unsigned int id;
+        char *rc_codes;
+};
+
+static char *af9015_rc_setup_match(unsigned int id,
+        const struct af9015_rc_setup *table)
+{
+        for (; table->rc_codes; table++)
+                if (table->id == id)
+                        return table->rc_codes;
+        return NULL;
+}
+
+static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
+        { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
+        { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
+        { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
+        { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
+        { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
+        { }
+};
+
+static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
+        { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
+        { 0xa3703d00, RC_MAP_ALINK_DTU_M },
+        { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */
+        { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */
+        { }
+};
+
+static const struct af9015_rc_setup af9015_rc_setup_usbids[] = {
+        { (USB_VID_TERRATEC << 16) + USB_PID_TERRATEC_CINERGY_T_STICK_RC,
+                RC_MAP_TERRATEC_SLIM_2 },
+        { (USB_VID_TERRATEC << 16) + USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
+                RC_MAP_TERRATEC_SLIM },
+        { (USB_VID_VISIONPLUS << 16) + USB_PID_AZUREWAVE_AD_TU700,
+                RC_MAP_AZUREWAVE_AD_TU700 },
+        { (USB_VID_VISIONPLUS << 16) + USB_PID_TINYTWIN,
+                RC_MAP_AZUREWAVE_AD_TU700 },
+        { (USB_VID_MSI_2 << 16) + USB_PID_MSI_DIGI_VOX_MINI_III,
+                RC_MAP_MSI_DIGIVOX_III },
+        { (USB_VID_MSI_2 << 16) + USB_PID_MSI_DIGIVOX_DUO,
+                RC_MAP_MSI_DIGIVOX_III },
+        { (USB_VID_LEADTEK << 16) + USB_PID_WINFAST_DTV_DONGLE_GOLD,
+                RC_MAP_LEADTEK_Y04G0051 },
+        { (USB_VID_AVERMEDIA << 16) + USB_PID_AVERMEDIA_VOLAR_X,
+                RC_MAP_AVERMEDIA_M135A },
+        { (USB_VID_AFATECH << 16) + USB_PID_TREKSTOR_DVBT,
+                RC_MAP_TREKSTOR },
+        { (USB_VID_KWORLD_2 << 16) + USB_PID_TINYTWIN_2,
+                RC_MAP_DIGITALNOW_TINYTWIN },
+        { (USB_VID_GTEK << 16) + USB_PID_TINYTWIN_3,
+                RC_MAP_DIGITALNOW_TINYTWIN },
+        { (USB_VID_KWORLD_2 << 16) + USB_PID_SVEON_STV22,
+                RC_MAP_MSI_DIGIVOX_III },
+        { }
+};
+
+static void af9015_set_remote_config(struct usb_device *udev,
+                struct dvb_usb_device_properties *props)
+{
+        u16 vid = le16_to_cpu(udev->descriptor.idVendor);
+        u16 pid = le16_to_cpu(udev->descriptor.idProduct);
+
+        /* try to load remote based module param */
+        props->rc.core.rc_codes = af9015_rc_setup_match(
+                dvb_usb_af9015_remote, af9015_rc_setup_modparam);
+
+        /* try to load remote based eeprom hash */
+        if (!props->rc.core.rc_codes)
+                props->rc.core.rc_codes = af9015_rc_setup_match(
+                        af9015_config.eeprom_sum, af9015_rc_setup_hashes);
+
+        /* try to load remote based USB ID */
+        if (!props->rc.core.rc_codes)
+                props->rc.core.rc_codes = af9015_rc_setup_match(
+                        (vid << 16) + pid, af9015_rc_setup_usbids);
+
+        /* try to load remote based USB iManufacturer string */
+        if (!props->rc.core.rc_codes && vid == USB_VID_AFATECH) {
+                /* Check USB manufacturer and product strings and try
+                   to determine correct remote in case of chip vendor
+                   reference IDs are used.
+                   DO NOT ADD ANYTHING NEW HERE. Use hashes instead. */
+                char manufacturer[10];
+                memset(manufacturer, 0, sizeof(manufacturer));
+                usb_string(udev, udev->descriptor.iManufacturer,
+                        manufacturer, sizeof(manufacturer));
+                if (!strcmp("MSI", manufacturer)) {
+                        /* iManufacturer 1 MSI
+                           iProduct      2 MSI K-VOX */
+                        props->rc.core.rc_codes = af9015_rc_setup_match(
+                                AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
+                                af9015_rc_setup_modparam);
+                }
+        }
+
+        /* finally load "empty" just for leaving IR receiver enabled */
+        if (!props->rc.core.rc_codes)
+                props->rc.core.rc_codes = RC_MAP_EMPTY;
+
+        return;
+}
+
+static int af9015_read_config(struct usb_device *udev)
+{
+        int ret;
+        u8 val, i, offset = 0;
+        struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
+
+        /* IR remote controller */
+        req.addr = AF9015_EEPROM_IR_MODE;
+        /* first message will timeout often due to possible hw bug */
+        for (i = 0; i < 4; i++) {
+                ret = af9015_rw_udev(udev, &req);
+                if (!ret)
+                        break;
+        }
+        if (ret)
+                goto error;
+
+        ret = af9015_eeprom_hash(udev);
+        if (ret)
+                goto error;
+
+        deb_info("%s: IR mode:%d\n", __func__, val);
+        for (i = 0; i < af9015_properties_count; i++) {
+                if (val == AF9015_IR_MODE_DISABLED)
+                        af9015_properties[i].rc.core.rc_codes = NULL;
+                else
+                        af9015_set_remote_config(udev, &af9015_properties[i]);
+        }
+
+        /* TS mode - one or two receivers */
+        req.addr = AF9015_EEPROM_TS_MODE;
+        ret = af9015_rw_udev(udev, &req);
+        if (ret)
+                goto error;
+        af9015_config.dual_mode = val;
+        deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
+
+        /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
+           size can be static because it is enabled only USB2.0 */
+        for (i = 0; i < af9015_properties_count; i++) {
+                /* USB1.1 set smaller buffersize and disable 2nd adapter */
+                if (udev->speed == USB_SPEED_FULL) {
+                        af9015_properties[i].adapter[0].stream.u.bulk.buffersize
+                                = TS_USB11_FRAME_SIZE;
+                        /* disable 2nd adapter because we don't have
+                           PID-filters */
+                        af9015_config.dual_mode = 0;
+                } else {
+                        af9015_properties[i].adapter[0].stream.u.bulk.buffersize
+                                = TS_USB20_FRAME_SIZE;
+                }
+        }
+
+        if (af9015_config.dual_mode) {
+                /* read 2nd demodulator I2C address */
+                req.addr = AF9015_EEPROM_DEMOD2_I2C;
+                ret = af9015_rw_udev(udev, &req);
+                if (ret)
+                        goto error;
+                af9015_af9013_config[1].demod_address = val;
+
+                /* enable 2nd adapter */
+                for (i = 0; i < af9015_properties_count; i++)
+                        af9015_properties[i].num_adapters = 2;
+
+        } else {
+                 /* disable 2nd adapter */
+                for (i = 0; i < af9015_properties_count; i++)
+                        af9015_properties[i].num_adapters = 1;
+        }
+
+        for (i = 0; i < af9015_properties[0].num_adapters; i++) {
+                if (i == 1)
+                        offset = AF9015_EEPROM_OFFSET;
+                /* xtal */
+                req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
+                ret = af9015_rw_udev(udev, &req);
+                if (ret)
+                        goto error;
+                switch (val) {
+                case 0:
+                        af9015_af9013_config[i].adc_clock = 28800;
+                        break;
+                case 1:
+                        af9015_af9013_config[i].adc_clock = 20480;
+                        break;
+                case 2:
+                        af9015_af9013_config[i].adc_clock = 28000;
+                        break;
+                case 3:
+                        af9015_af9013_config[i].adc_clock = 25000;
+                        break;
+                };
+                deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
+                        val, af9015_af9013_config[i].adc_clock);
+
+                /* tuner IF */
+                req.addr = AF9015_EEPROM_IF1H + offset;
+                ret = af9015_rw_udev(udev, &req);
+                if (ret)
+                        goto error;
+                af9015_af9013_config[i].tuner_if = val << 8;
+                req.addr = AF9015_EEPROM_IF1L + offset;
+                ret = af9015_rw_udev(udev, &req);
+                if (ret)
+                        goto error;
+                af9015_af9013_config[i].tuner_if += val;
+                deb_info("%s: [%d] IF1:%d\n", __func__, i,
+                        af9015_af9013_config[0].tuner_if);
+
+                /* MT2060 IF1 */
+                req.addr = AF9015_EEPROM_MT2060_IF1H  + offset;
+                ret = af9015_rw_udev(udev, &req);
+                if (ret)
+                        goto error;
+                af9015_config.mt2060_if1[i] = val << 8;
+                req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
+                ret = af9015_rw_udev(udev, &req);
+                if (ret)
+                        goto error;
+                af9015_config.mt2060_if1[i] += val;
+                deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
+                        af9015_config.mt2060_if1[i]);
+
+                /* tuner */
+                req.addr =  AF9015_EEPROM_TUNER_ID1 + offset;
+                ret = af9015_rw_udev(udev, &req);
+                if (ret)
+                        goto error;
+                switch (val) {
+                case AF9013_TUNER_ENV77H11D5:
+                case AF9013_TUNER_MT2060:
+                case AF9013_TUNER_QT1010:
+                case AF9013_TUNER_UNKNOWN:
+                case AF9013_TUNER_MT2060_2:
+                case AF9013_TUNER_TDA18271:
+                case AF9013_TUNER_QT1010A:
+                case AF9013_TUNER_TDA18218:
+                        af9015_af9013_config[i].rf_spec_inv = 1;
+                        break;
+                case AF9013_TUNER_MXL5003D:
+                case AF9013_TUNER_MXL5005D:
+                case AF9013_TUNER_MXL5005R:
+                case AF9013_TUNER_MXL5007T:
+                        af9015_af9013_config[i].rf_spec_inv = 0;
+                        break;
+                case AF9013_TUNER_MC44S803:
+                        af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
+                        af9015_af9013_config[i].rf_spec_inv = 1;
+                        break;
+                default:
+                        warn("tuner id:%d not supported, please report!", val);
+                        return -ENODEV;
+                };
+
+                af9015_af9013_config[i].tuner = val;
+                deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
+        }
+
+error:
+        if (ret)
+                err("eeprom read failed:%d", ret);
+
+        /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
+           content :-( Override some wrong values here. Ditto for the
+           AVerTV Red HD+ (A850T) device. */
+        if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
+                ((le16_to_cpu(udev->descriptor.idProduct) ==
+                        USB_PID_AVERMEDIA_A850) ||
+                (le16_to_cpu(udev->descriptor.idProduct) ==
+                        USB_PID_AVERMEDIA_A850T))) {
+                deb_info("%s: AverMedia A850: overriding config\n", __func__);
+                /* disable dual mode */
+                af9015_config.dual_mode = 0;
+                 /* disable 2nd adapter */
+                for (i = 0; i < af9015_properties_count; i++)
+                        af9015_properties[i].num_adapters = 1;
+
+                /* set correct IF */
+                af9015_af9013_config[0].tuner_if = 4570;
+        }
+
+        return ret;
+}
+
+static int af9015_identify_state(struct usb_device *udev,
+                                 struct dvb_usb_device_properties *props,
+                                 struct dvb_usb_device_description **desc,
+                                 int *cold)
+{
+        int ret;
+        u8 reply;
+        struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
+
+        ret = af9015_rw_udev(udev, &req);
+        if (ret)
+                return ret;
+
+        deb_info("%s: reply:%02x\n", __func__, reply);
+        if (reply == 0x02)
+                *cold = 0;
+        else
+                *cold = 1;
+
+        return ret;
+}
+
+static int af9015_rc_query(struct dvb_usb_device *d)
+{
+        struct af9015_state *priv = d->priv;
+        int ret;
+        u8 buf[17];
+
+        /* read registers needed to detect remote controller code */
+        ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
+        if (ret)
+                goto error;
+
+        /* If any of these are non-zero, assume invalid data */
+        if (buf[1] || buf[2] || buf[3])
+                return ret;
+
+        /* Check for repeat of previous code */
+        if ((priv->rc_repeat != buf[6] || buf[0]) &&
+                                        !memcmp(&buf[12], priv->rc_last, 4)) {
+                deb_rc("%s: key repeated\n", __func__);
+                rc_keydown(d->rc_dev, priv->rc_keycode, 0);
+                priv->rc_repeat = buf[6];
+                return ret;
+        }
+
+        /* Only process key if canary killed */
+        if (buf[16] != 0xff && buf[0] != 0x01) {
+                deb_rc("%s: key pressed %02x %02x %02x %02x\n", __func__,
+                        buf[12], buf[13], buf[14], buf[15]);
+
+                /* Reset the canary */
+                ret = af9015_write_reg(d, 0x98e9, 0xff);
+                if (ret)
+                        goto error;
+
+                /* Remember this key */
+                memcpy(priv->rc_last, &buf[12], 4);
+                if (buf[14] == (u8) ~buf[15]) {
+                        if (buf[12] == (u8) ~buf[13]) {
+                                /* NEC */
+                                priv->rc_keycode = buf[12] << 8 | buf[14];
+                        } else {
+                                /* NEC extended*/
+                                priv->rc_keycode = buf[12] << 16 |
+                                        buf[13] << 8 | buf[14];
+                        }
+                } else {
+                        /* 32 bit NEC */
+                        priv->rc_keycode = buf[12] << 24 | buf[13] << 16 |
+                                        buf[14] << 8 | buf[15];
+                }
+                rc_keydown(d->rc_dev, priv->rc_keycode, 0);
+        } else {
+                deb_rc("%s: no key press\n", __func__);
+                /* Invalidate last keypress */
+                /* Not really needed, but helps with debug */
+                priv->rc_last[2] = priv->rc_last[3];
+        }
+
+        priv->rc_repeat = buf[6];
+
+error:
+        if (ret)
+                err("%s: failed:%d", __func__, ret);
+
+        return ret;
+}
+
+static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        int ret;
+
+        if (adap->id == 1) {
+                /* copy firmware to 2nd demodulator */
+                if (af9015_config.dual_mode) {
+                        ret = af9015_copy_firmware(adap->dev);
+                        if (ret) {
+                                err("firmware copy to 2nd frontend " \
+                                        "failed, will disable it");
+                                af9015_config.dual_mode = 0;
+                                return -ENODEV;
+                        }
+                } else {
+                        return -ENODEV;
+                }
+        }
+
+        /* attach demodulator */
+        adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
+                &adap->dev->i2c_adap);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static struct mt2060_config af9015_mt2060_config = {
+        .i2c_address = 0xc0,
+        .clock_out = 0,
+};
+
+static struct qt1010_config af9015_qt1010_config = {
+        .i2c_address = 0xc4,
+};
+
+static struct tda18271_config af9015_tda18271_config = {
+        .gate = TDA18271_GATE_DIGITAL,
+        .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
+};
+
+static struct mxl5005s_config af9015_mxl5003_config = {
+        .i2c_address     = 0xc6,
+        .if_freq         = IF_FREQ_4570000HZ,
+        .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
+        .agc_mode        = MXL_SINGLE_AGC,
+        .tracking_filter = MXL_TF_DEFAULT,
+        .rssi_enable     = MXL_RSSI_ENABLE,
+        .cap_select      = MXL_CAP_SEL_ENABLE,
+        .div_out         = MXL_DIV_OUT_4,
+        .clock_out       = MXL_CLOCK_OUT_DISABLE,
+        .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
+        .top             = MXL5005S_TOP_25P2,
+        .mod_mode        = MXL_DIGITAL_MODE,
+        .if_mode         = MXL_ZERO_IF,
+        .AgcMasterByte   = 0x00,
+};
+
+static struct mxl5005s_config af9015_mxl5005_config = {
+        .i2c_address     = 0xc6,
+        .if_freq         = IF_FREQ_4570000HZ,
+        .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
+        .agc_mode        = MXL_SINGLE_AGC,
+        .tracking_filter = MXL_TF_OFF,
+        .rssi_enable     = MXL_RSSI_ENABLE,
+        .cap_select      = MXL_CAP_SEL_ENABLE,
+        .div_out         = MXL_DIV_OUT_4,
+        .clock_out       = MXL_CLOCK_OUT_DISABLE,
+        .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
+        .top             = MXL5005S_TOP_25P2,
+        .mod_mode        = MXL_DIGITAL_MODE,
+        .if_mode         = MXL_ZERO_IF,
+        .AgcMasterByte   = 0x00,
+};
+
+static struct mc44s803_config af9015_mc44s803_config = {
+        .i2c_address = 0xc0,
+        .dig_out = 1,
+};
+
+static struct tda18218_config af9015_tda18218_config = {
+        .i2c_address = 0xc0,
+        .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
+};
+
+static struct mxl5007t_config af9015_mxl5007t_config = {
+        .xtal_freq_hz = MxL_XTAL_24_MHZ,
+        .if_freq_hz = MxL_IF_4_57_MHZ,
+};
+
+static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        int ret;
+        deb_info("%s:\n", __func__);
+
+        switch (af9015_af9013_config[adap->id].tuner) {
+        case AF9013_TUNER_MT2060:
+        case AF9013_TUNER_MT2060_2:
+                ret = dvb_attach(mt2060_attach, adap->fe, &adap->dev->i2c_adap,
+                        &af9015_mt2060_config,
+                        af9015_config.mt2060_if1[adap->id])
+                        == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_QT1010:
+        case AF9013_TUNER_QT1010A:
+                ret = dvb_attach(qt1010_attach, adap->fe, &adap->dev->i2c_adap,
+                        &af9015_qt1010_config) == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_TDA18271:
+                ret = dvb_attach(tda18271_attach, adap->fe, 0xc0,
+                        &adap->dev->i2c_adap,
+                        &af9015_tda18271_config) == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_TDA18218:
+                ret = dvb_attach(tda18218_attach, adap->fe,
+                        &adap->dev->i2c_adap,
+                        &af9015_tda18218_config) == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_MXL5003D:
+                ret = dvb_attach(mxl5005s_attach, adap->fe,
+                        &adap->dev->i2c_adap,
+                        &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_MXL5005D:
+        case AF9013_TUNER_MXL5005R:
+                ret = dvb_attach(mxl5005s_attach, adap->fe,
+                        &adap->dev->i2c_adap,
+                        &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_ENV77H11D5:
+                ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0,
+                        &adap->dev->i2c_adap,
+                        DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_MC44S803:
+                ret = dvb_attach(mc44s803_attach, adap->fe,
+                        &adap->dev->i2c_adap,
+                        &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_MXL5007T:
+                ret = dvb_attach(mxl5007t_attach, adap->fe,
+                        &adap->dev->i2c_adap,
+                        0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
+                break;
+        case AF9013_TUNER_UNKNOWN:
+        default:
+                ret = -ENODEV;
+                err("Unknown tuner id:%d",
+                        af9015_af9013_config[adap->id].tuner);
+        }
+        return ret;
+}
+
+static struct usb_device_id af9015_usb_table[] = {
+/*  0 */{USB_DEVICE(USB_VID_AFATECH,   USB_PID_AFATECH_AF9015_9015)},
+        {USB_DEVICE(USB_VID_AFATECH,   USB_PID_AFATECH_AF9015_9016)},
+        {USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_GOLD)},
+        {USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV71E)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_399U)},
+/*  5 */{USB_DEVICE(USB_VID_VISIONPLUS,
+                USB_PID_TINYTWIN)},
+        {USB_DEVICE(USB_VID_VISIONPLUS,
+                USB_PID_AZUREWAVE_AD_TU700)},
+        {USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_PC160_2T)},
+        {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
+/* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
+        {USB_DEVICE(USB_VID_MSI_2,     USB_PID_MSI_DIGIVOX_DUO)},
+        {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
+        {USB_DEVICE(USB_VID_TELESTAR,  USB_PID_TELESTAR_STARSTICK_2)},
+        {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
+/* 15 */{USB_DEVICE(USB_VID_MSI_2,     USB_PID_MSI_DIGI_VOX_MINI_III)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_2)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_3)},
+        {USB_DEVICE(USB_VID_AFATECH,   USB_PID_TREKSTOR_DVBT)},
+/* 20 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
+        {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_CONCEPTRONIC_CTVDIGRCU)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_MC810)},
+        {USB_DEVICE(USB_VID_KYE,       USB_PID_GENIUS_TVGO_DVB_T03)},
+/* 25 */{USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_399U_2)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_PC160_T)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_SVEON_STV20)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_TINYTWIN_2)},
+        {USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV2000DS)},
+/* 30 */{USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_UB383_T)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_4)},
+        {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M)},
+        {USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_STICK_RC)},
+        {USB_DEVICE(USB_VID_TERRATEC,
+                USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC)},
+/* 35 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T)},
+        {USB_DEVICE(USB_VID_GTEK,      USB_PID_TINYTWIN_3)},
+        {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_SVEON_STV22)},
+        {0},
+};
+MODULE_DEVICE_TABLE(usb, af9015_usb_table);
+
+#define AF9015_RC_INTERVAL 500
+static struct dvb_usb_device_properties af9015_properties[] = {
+        {
+                .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+                .usb_ctrl = DEVICE_SPECIFIC,
+                .download_firmware = af9015_download_firmware,
+                .firmware = "dvb-usb-af9015.fw",
+                .no_reconnect = 1,
+
+                .size_of_priv = sizeof(struct af9015_state),
+
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                                DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                                .pid_filter_count = 32,
+                                .pid_filter       = af9015_pid_filter,
+                                .pid_filter_ctrl  = af9015_pid_filter_ctrl,
+
+                                .frontend_attach =
+                                        af9015_af9013_frontend_attach,
+                                .tuner_attach    = af9015_tuner_attach,
+                                .stream = {
+                                        .type = USB_BULK,
+                                        .count = 6,
+                                        .endpoint = 0x84,
+                                },
+                        },
+                        {
+                                .frontend_attach =
+                                        af9015_af9013_frontend_attach,
+                                .tuner_attach    = af9015_tuner_attach,
+                                .stream = {
+                                        .type = USB_BULK,
+                                        .count = 6,
+                                        .endpoint = 0x85,
+                                        .u = {
+                                                .bulk = {
+                                                        .buffersize =
+                                                TS_USB20_FRAME_SIZE,
+                                                }
+                                        }
+                                },
+                        }
+                },
+
+                .identify_state = af9015_identify_state,
+
+                .rc.core = {
+                        .protocol         = RC_TYPE_NEC,
+                        .module_name      = "af9015",
+                        .rc_query         = af9015_rc_query,
+                        .rc_interval      = AF9015_RC_INTERVAL,
+                        .allowed_protos   = RC_TYPE_NEC,
+                },
+
+                .i2c_algo = &af9015_i2c_algo,
+
+                .num_device_descs = 12, /* check max from dvb-usb.h */
+                .devices = {
+                        {
+                                .name = "Afatech AF9015 DVB-T USB2.0 stick",
+                                .cold_ids = {&af9015_usb_table[0],
+                                             &af9015_usb_table[1], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Leadtek WinFast DTV Dongle Gold",
+                                .cold_ids = {&af9015_usb_table[2], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Pinnacle PCTV 71e",
+                                .cold_ids = {&af9015_usb_table[3], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "KWorld PlusTV Dual DVB-T Stick " \
+                                        "(DVB-T 399U)",
+                                .cold_ids = {&af9015_usb_table[4],
+                                             &af9015_usb_table[25], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "DigitalNow TinyTwin DVB-T Receiver",
+                                .cold_ids = {&af9015_usb_table[5],
+                                             &af9015_usb_table[28],
+                                             &af9015_usb_table[36], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "TwinHan AzureWave AD-TU700(704J)",
+                                .cold_ids = {&af9015_usb_table[6], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "TerraTec Cinergy T USB XE",
+                                .cold_ids = {&af9015_usb_table[7], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "KWorld PlusTV Dual DVB-T PCI " \
+                                        "(DVB-T PC160-2T)",
+                                .cold_ids = {&af9015_usb_table[8], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "AVerMedia AVerTV DVB-T Volar X",
+                                .cold_ids = {&af9015_usb_table[9], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "TerraTec Cinergy T Stick RC",
+                                .cold_ids = {&af9015_usb_table[33], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "TerraTec Cinergy T Stick Dual RC",
+                                .cold_ids = {&af9015_usb_table[34], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "AverMedia AVerTV Red HD+ (A850T)",
+                                .cold_ids = {&af9015_usb_table[35], NULL},
+                                .warm_ids = {NULL},
+                        },
+                }
+        }, {
+                .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+                .usb_ctrl = DEVICE_SPECIFIC,
+                .download_firmware = af9015_download_firmware,
+                .firmware = "dvb-usb-af9015.fw",
+                .no_reconnect = 1,
+
+                .size_of_priv = sizeof(struct af9015_state),
+
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                                DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                                .pid_filter_count = 32,
+                                .pid_filter       = af9015_pid_filter,
+                                .pid_filter_ctrl  = af9015_pid_filter_ctrl,
+
+                                .frontend_attach =
+                                        af9015_af9013_frontend_attach,
+                                .tuner_attach    = af9015_tuner_attach,
+                                .stream = {
+                                        .type = USB_BULK,
+                                        .count = 6,
+                                        .endpoint = 0x84,
+                                },
+                        },
+                        {
+                                .frontend_attach =
+                                        af9015_af9013_frontend_attach,
+                                .tuner_attach    = af9015_tuner_attach,
+                                .stream = {
+                                        .type = USB_BULK,
+                                        .count = 6,
+                                        .endpoint = 0x85,
+                                        .u = {
+                                                .bulk = {
+                                                        .buffersize =
+                                                TS_USB20_FRAME_SIZE,
+                                                }
+                                        }
+                                },
+                        }
+                },
+
+                .identify_state = af9015_identify_state,
+
+                .rc.core = {
+                        .protocol         = RC_TYPE_NEC,
+                        .module_name      = "af9015",
+                        .rc_query         = af9015_rc_query,
+                        .rc_interval      = AF9015_RC_INTERVAL,
+                        .allowed_protos   = RC_TYPE_NEC,
+                },
+
+                .i2c_algo = &af9015_i2c_algo,
+
+                .num_device_descs = 10, /* check max from dvb-usb.h */
+                .devices = {
+                        {
+                                .name = "Xtensions XD-380",
+                                .cold_ids = {&af9015_usb_table[10], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "MSI DIGIVOX Duo",
+                                .cold_ids = {&af9015_usb_table[11], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
+                                .cold_ids = {&af9015_usb_table[12], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Telestar Starstick 2",
+                                .cold_ids = {&af9015_usb_table[13], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "AVerMedia A309",
+                                .cold_ids = {&af9015_usb_table[14], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "MSI Digi VOX mini III",
+                                .cold_ids = {&af9015_usb_table[15], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "KWorld USB DVB-T TV Stick II " \
+                                        "(VS-DVB-T 395U)",
+                                .cold_ids = {&af9015_usb_table[16],
+                                             &af9015_usb_table[17],
+                                             &af9015_usb_table[18],
+                                             &af9015_usb_table[31], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "TrekStor DVB-T USB Stick",
+                                .cold_ids = {&af9015_usb_table[19], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "AverMedia AVerTV Volar Black HD " \
+                                        "(A850)",
+                                .cold_ids = {&af9015_usb_table[20], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Sveon STV22 Dual USB DVB-T Tuner HDTV",
+                                .cold_ids = {&af9015_usb_table[37], NULL},
+                                .warm_ids = {NULL},
+                        },
+                }
+        }, {
+                .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+                .usb_ctrl = DEVICE_SPECIFIC,
+                .download_firmware = af9015_download_firmware,
+                .firmware = "dvb-usb-af9015.fw",
+                .no_reconnect = 1,
+
+                .size_of_priv = sizeof(struct af9015_state),
+
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                                DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                                .pid_filter_count = 32,
+                                .pid_filter       = af9015_pid_filter,
+                                .pid_filter_ctrl  = af9015_pid_filter_ctrl,
+
+                                .frontend_attach =
+                                        af9015_af9013_frontend_attach,
+                                .tuner_attach    = af9015_tuner_attach,
+                                .stream = {
+                                        .type = USB_BULK,
+                                        .count = 6,
+                                        .endpoint = 0x84,
+                                },
+                        },
+                        {
+                                .frontend_attach =
+                                        af9015_af9013_frontend_attach,
+                                .tuner_attach    = af9015_tuner_attach,
+                                .stream = {
+                                        .type = USB_BULK,
+                                        .count = 6,
+                                        .endpoint = 0x85,
+                                        .u = {
+                                                .bulk = {
+                                                        .buffersize =
+                                                TS_USB20_FRAME_SIZE,
+                                                }
+                                        }
+                                },
+                        }
+                },
+
+                .identify_state = af9015_identify_state,
+
+                .rc.core = {
+                        .protocol         = RC_TYPE_NEC,
+                        .module_name      = "af9015",
+                        .rc_query         = af9015_rc_query,
+                        .rc_interval      = AF9015_RC_INTERVAL,
+                        .allowed_protos   = RC_TYPE_NEC,
+                },
+
+                .i2c_algo = &af9015_i2c_algo,
+
+                .num_device_descs = 9, /* check max from dvb-usb.h */
+                .devices = {
+                        {
+                                .name = "AverMedia AVerTV Volar GPS 805 (A805)",
+                                .cold_ids = {&af9015_usb_table[21], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
+                                        "V3.0",
+                                .cold_ids = {&af9015_usb_table[22], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "KWorld Digial MC-810",
+                                .cold_ids = {&af9015_usb_table[23], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Genius TVGo DVB-T03",
+                                .cold_ids = {&af9015_usb_table[24], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "KWorld PlusTV DVB-T PCI Pro Card " \
+                                        "(DVB-T PC160-T)",
+                                .cold_ids = {&af9015_usb_table[26], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Sveon STV20 Tuner USB DVB-T HDTV",
+                                .cold_ids = {&af9015_usb_table[27], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "Leadtek WinFast DTV2000DS",
+                                .cold_ids = {&af9015_usb_table[29], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "KWorld USB DVB-T Stick Mobile " \
+                                        "(UB383-T)",
+                                .cold_ids = {&af9015_usb_table[30], NULL},
+                                .warm_ids = {NULL},
+                        },
+                        {
+                                .name = "AverMedia AVerTV Volar M (A815Mac)",
+                                .cold_ids = {&af9015_usb_table[32], NULL},
+                                .warm_ids = {NULL},
+                        },
+                }
+        },
+};
+
+static int af9015_usb_probe(struct usb_interface *intf,
+                            const struct usb_device_id *id)
+{
+        int ret = 0;
+        struct dvb_usb_device *d = NULL;
+        struct usb_device *udev = interface_to_usbdev(intf);
+        u8 i;
+
+        deb_info("%s: interface:%d\n", __func__,
+                intf->cur_altsetting->desc.bInterfaceNumber);
+
+        /* interface 0 is used by DVB-T receiver and
+           interface 1 is for remote controller (HID) */
+        if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
+                ret = af9015_read_config(udev);
+                if (ret)
+                        return ret;
+
+                for (i = 0; i < af9015_properties_count; i++) {
+                        ret = dvb_usb_device_init(intf, &af9015_properties[i],
+                                THIS_MODULE, &d, adapter_nr);
+                        if (!ret)
+                                break;
+                        if (ret != -ENODEV)
+                                return ret;
+                }
+                if (ret)
+                        return ret;
+
+                if (d)
+                        ret = af9015_init(d);
+        }
+
+        return ret;
+}
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver af9015_usb_driver = {
+        .name = "dvb_usb_af9015",
+        .probe = af9015_usb_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table = af9015_usb_table,
+};
+
+/* module stuff */
+static int __init af9015_usb_module_init(void)
+{
+        int ret;
+        ret = usb_register(&af9015_usb_driver);
+        if (ret)
+                err("module init failed:%d", ret);
+
+        return ret;
+}
+
+static void __exit af9015_usb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&af9015_usb_driver);
+}
+
+module_init(af9015_usb_module_init);
+module_exit(af9015_usb_module_exit);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/af9015.h b/drivers/media/dvb/dvb-usb/af9015.h
new file mode 100644
index 00000000000..6252ea6c190
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/af9015.h
@@ -0,0 +1,124 @@
+/*
+ * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
+ *
+ * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
+ *
+ * Thanks to Afatech who kindly provided information.
+ *
+ *    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_USB_AF9015_H_
+#define _DVB_USB_AF9015_H_
+
+#define DVB_USB_LOG_PREFIX "af9015"
+#include "dvb-usb.h"
+
+#define deb_info(args...) dprintk(dvb_usb_af9015_debug, 0x01, args)
+#define deb_rc(args...)   dprintk(dvb_usb_af9015_debug, 0x02, args)
+#define deb_xfer(args...) dprintk(dvb_usb_af9015_debug, 0x04, args)
+#define deb_reg(args...)  dprintk(dvb_usb_af9015_debug, 0x08, args)
+#define deb_i2c(args...)  dprintk(dvb_usb_af9015_debug, 0x10, args)
+#define deb_fw(args...)   dprintk(dvb_usb_af9015_debug, 0x20, args)
+
+#define AF9015_I2C_EEPROM  0xa0
+#define AF9015_I2C_DEMOD   0x38
+#define AF9015_USB_TIMEOUT 2000
+
+/* EEPROM locations */
+#define AF9015_EEPROM_IR_MODE        0x18
+#define AF9015_EEPROM_IR_REMOTE_TYPE 0x34
+#define AF9015_EEPROM_TS_MODE        0x31
+#define AF9015_EEPROM_DEMOD2_I2C     0x32
+
+#define AF9015_EEPROM_SAW_BW1        0x35
+#define AF9015_EEPROM_XTAL_TYPE1     0x36
+#define AF9015_EEPROM_SPEC_INV1      0x37
+#define AF9015_EEPROM_IF1L           0x38
+#define AF9015_EEPROM_IF1H           0x39
+#define AF9015_EEPROM_MT2060_IF1L    0x3a
+#define AF9015_EEPROM_MT2060_IF1H    0x3b
+#define AF9015_EEPROM_TUNER_ID1      0x3c
+
+#define AF9015_EEPROM_SAW_BW2        0x45
+#define AF9015_EEPROM_XTAL_TYPE2     0x46
+#define AF9015_EEPROM_SPEC_INV2      0x47
+#define AF9015_EEPROM_IF2L           0x48
+#define AF9015_EEPROM_IF2H           0x49
+#define AF9015_EEPROM_MT2060_IF2L    0x4a
+#define AF9015_EEPROM_MT2060_IF2H    0x4b
+#define AF9015_EEPROM_TUNER_ID2      0x4c
+
+#define AF9015_EEPROM_OFFSET (AF9015_EEPROM_SAW_BW2 - AF9015_EEPROM_SAW_BW1)
+
+struct req_t {
+        u8  cmd;       /* [0] */
+        /*  seq */     /* [1] */
+        u8  i2c_addr;  /* [2] */
+        u16 addr;      /* [3|4] */
+        u8  mbox;      /* [5] */
+        u8  addr_len;  /* [6] */
+        u8  data_len;  /* [7] */
+        u8  *data;
+};
+
+enum af9015_cmd {
+        GET_CONFIG           = 0x10,
+        DOWNLOAD_FIRMWARE    = 0x11,
+        BOOT                 = 0x13,
+        READ_MEMORY          = 0x20,
+        WRITE_MEMORY         = 0x21,
+        READ_WRITE_I2C       = 0x22,
+        COPY_FIRMWARE        = 0x23,
+        RECONNECT_USB        = 0x5a,
+        WRITE_VIRTUAL_MEMORY = 0x26,
+        GET_IR_CODE          = 0x27,
+        READ_I2C,
+        WRITE_I2C,
+};
+
+enum af9015_ir_mode {
+        AF9015_IR_MODE_DISABLED = 0,
+        AF9015_IR_MODE_HID,
+        AF9015_IR_MODE_RLC,
+        AF9015_IR_MODE_RC6,
+        AF9015_IR_MODE_POLLING, /* just guess */
+};
+
+struct af9015_state {
+        u8 rc_repeat;
+        u32 rc_keycode;
+        u8 rc_last[4];
+};
+
+struct af9015_config {
+        u8  dual_mode:1;
+        u16 mt2060_if1[2];
+        u16 firmware_size;
+        u16 firmware_checksum;
+        u32 eeprom_sum;
+};
+
+enum af9015_remote {
+        AF9015_REMOTE_NONE                    = 0,
+/* 1 */ AF9015_REMOTE_A_LINK_DTU_M,
+        AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
+        AF9015_REMOTE_MYGICTV_U718,
+        AF9015_REMOTE_DIGITTRADE_DVB_T,
+/* 5 */ AF9015_REMOTE_AVERMEDIA_KS,
+};
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/anysee.c b/drivers/media/dvb/dvb-usb/anysee.c
new file mode 100644
index 00000000000..2cbf19a52e3
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/anysee.c
@@ -0,0 +1,990 @@
+/*
+ * DVB USB Linux driver for Anysee E30 DVB-C & DVB-T USB2.0 receiver
+ *
+ * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
+ *
+ *    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.
+ *
+ * TODO:
+ * - add smart card reader support for Conditional Access (CA)
+ *
+ * Card reader in Anysee is nothing more than ISO 7816 card reader.
+ * There is no hardware CAM in any Anysee device sold.
+ * In my understanding it should be implemented by making own module
+ * for ISO 7816 card reader, like dvb_ca_en50221 is implemented. This
+ * module registers serial interface that can be used to communicate
+ * with any ISO 7816 smart card.
+ *
+ * Any help according to implement serial smart card reader support
+ * is highly welcome!
+ */
+
+#include "anysee.h"
+#include "tda1002x.h"
+#include "mt352.h"
+#include "mt352_priv.h"
+#include "zl10353.h"
+#include "tda18212.h"
+#include "cx24116.h"
+#include "stv0900.h"
+#include "stv6110.h"
+#include "isl6423.h"
+
+/* debug */
+static int dvb_usb_anysee_debug;
+module_param_named(debug, dvb_usb_anysee_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
+static int dvb_usb_anysee_delsys;
+module_param_named(delsys, dvb_usb_anysee_delsys, int, 0644);
+MODULE_PARM_DESC(delsys, "select delivery mode (0=DVB-C, 1=DVB-T)");
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static DEFINE_MUTEX(anysee_usb_mutex);
+
+static int anysee_ctrl_msg(struct dvb_usb_device *d, u8 *sbuf, u8 slen,
+        u8 *rbuf, u8 rlen)
+{
+        struct anysee_state *state = d->priv;
+        int act_len, ret;
+        u8 buf[64];
+
+        memcpy(&buf[0], sbuf, slen);
+        buf[60] = state->seq++;
+
+        if (mutex_lock_interruptible(&anysee_usb_mutex) < 0)
+                return -EAGAIN;
+
+        /* We need receive one message more after dvb_usb_generic_rw due
+           to weird transaction flow, which is 1 x send + 2 x receive. */
+        ret = dvb_usb_generic_rw(d, buf, sizeof(buf), buf, sizeof(buf), 0);
+
+        if (!ret) {
+                /* receive 2nd answer */
+                ret = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev,
+                        d->props.generic_bulk_ctrl_endpoint), buf, sizeof(buf),
+                        &act_len, 2000);
+                if (ret)
+                        err("%s: recv bulk message failed: %d", __func__, ret);
+                else {
+                        deb_xfer("<<< ");
+                        debug_dump(buf, act_len, deb_xfer);
+                }
+        }
+
+        /* read request, copy returned data to return buf */
+        if (!ret && rbuf && rlen)
+                memcpy(rbuf, buf, rlen);
+
+        mutex_unlock(&anysee_usb_mutex);
+
+        return ret;
+}
+
+static int anysee_read_reg(struct dvb_usb_device *d, u16 reg, u8 *val)
+{
+        u8 buf[] = {CMD_REG_READ, reg >> 8, reg & 0xff, 0x01};
+        int ret;
+        ret = anysee_ctrl_msg(d, buf, sizeof(buf), val, 1);
+        deb_info("%s: reg:%04x val:%02x\n", __func__, reg, *val);
+        return ret;
+}
+
+static int anysee_write_reg(struct dvb_usb_device *d, u16 reg, u8 val)
+{
+        u8 buf[] = {CMD_REG_WRITE, reg >> 8, reg & 0xff, 0x01, val};
+        deb_info("%s: reg:%04x val:%02x\n", __func__, reg, val);
+        return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
+}
+
+/* write single register with mask */
+static int anysee_wr_reg_mask(struct dvb_usb_device *d, u16 reg, u8 val,
+        u8 mask)
+{
+        int ret;
+        u8 tmp;
+
+        /* no need for read if whole reg is written */
+        if (mask != 0xff) {
+                ret = anysee_read_reg(d, reg, &tmp);
+                if (ret)
+                        return ret;
+
+                val &= mask;
+                tmp &= ~mask;
+                val |= tmp;
+        }
+
+        return anysee_write_reg(d, reg, val);
+}
+
+static int anysee_get_hw_info(struct dvb_usb_device *d, u8 *id)
+{
+        u8 buf[] = {CMD_GET_HW_INFO};
+        return anysee_ctrl_msg(d, buf, sizeof(buf), id, 3);
+}
+
+static int anysee_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        u8 buf[] = {CMD_STREAMING_CTRL, (u8)onoff, 0x00};
+        deb_info("%s: onoff:%02x\n", __func__, onoff);
+        return anysee_ctrl_msg(adap->dev, buf, sizeof(buf), NULL, 0);
+}
+
+static int anysee_led_ctrl(struct dvb_usb_device *d, u8 mode, u8 interval)
+{
+        u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x01, mode, interval};
+        deb_info("%s: state:%02x interval:%02x\n", __func__, mode, interval);
+        return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
+}
+
+static int anysee_ir_ctrl(struct dvb_usb_device *d, u8 onoff)
+{
+        u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x02, onoff};
+        deb_info("%s: onoff:%02x\n", __func__, onoff);
+        return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
+}
+
+static int anysee_init(struct dvb_usb_device *d)
+{
+        int ret;
+        /* LED light */
+        ret = anysee_led_ctrl(d, 0x01, 0x03);
+        if (ret)
+                return ret;
+
+        /* enable IR */
+        ret = anysee_ir_ctrl(d, 1);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+/* I2C */
+static int anysee_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
+        int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int ret = 0, inc, i = 0;
+        u8 buf[52]; /* 4 + 48 (I2C WR USB command header + I2C WR max) */
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        while (i < num) {
+                if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
+                        if (msg[i].len > 2 || msg[i+1].len > 60) {
+                                ret = -EOPNOTSUPP;
+                                break;
+                        }
+                        buf[0] = CMD_I2C_READ;
+                        buf[1] = (msg[i].addr << 1) | 0x01;
+                        buf[2] = msg[i].buf[0];
+                        buf[3] = msg[i].buf[1];
+                        buf[4] = msg[i].len-1;
+                        buf[5] = msg[i+1].len;
+                        ret = anysee_ctrl_msg(d, buf, 6, msg[i+1].buf,
+                                msg[i+1].len);
+                        inc = 2;
+                } else {
+                        if (msg[i].len > 48) {
+                                ret = -EOPNOTSUPP;
+                                break;
+                        }
+                        buf[0] = CMD_I2C_WRITE;
+                        buf[1] = (msg[i].addr << 1);
+                        buf[2] = msg[i].len;
+                        buf[3] = 0x01;
+                        memcpy(&buf[4], msg[i].buf, msg[i].len);
+                        ret = anysee_ctrl_msg(d, buf, 4 + msg[i].len, NULL, 0);
+                        inc = 1;
+                }
+                if (ret)
+                        break;
+
+                i += inc;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+
+        return ret ? ret : i;
+}
+
+static u32 anysee_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm anysee_i2c_algo = {
+        .master_xfer   = anysee_master_xfer,
+        .functionality = anysee_i2c_func,
+};
+
+static int anysee_mt352_demod_init(struct dvb_frontend *fe)
+{
+        static u8 clock_config[]   = { CLOCK_CTL,  0x38, 0x28 };
+        static u8 reset[]          = { RESET,      0x80 };
+        static u8 adc_ctl_1_cfg[]  = { ADC_CTL_1,  0x40 };
+        static u8 agc_cfg[]        = { AGC_TARGET, 0x28, 0x20 };
+        static u8 gpp_ctl_cfg[]    = { GPP_CTL,    0x33 };
+        static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
+
+        mt352_write(fe, clock_config,   sizeof(clock_config));
+        udelay(200);
+        mt352_write(fe, reset,          sizeof(reset));
+        mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
+
+        mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
+        mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
+        mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
+
+        return 0;
+}
+
+/* Callbacks for DVB USB */
+static struct tda10023_config anysee_tda10023_config = {
+        .demod_address = (0x1a >> 1),
+        .invert = 0,
+        .xtal   = 16000000,
+        .pll_m  = 11,
+        .pll_p  = 3,
+        .pll_n  = 1,
+        .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_C,
+        .deltaf = 0xfeeb,
+};
+
+static struct mt352_config anysee_mt352_config = {
+        .demod_address = (0x1e >> 1),
+        .demod_init    = anysee_mt352_demod_init,
+};
+
+static struct zl10353_config anysee_zl10353_config = {
+        .demod_address = (0x1e >> 1),
+        .parallel_ts = 1,
+};
+
+static struct zl10353_config anysee_zl10353_tda18212_config2 = {
+        .demod_address = (0x1e >> 1),
+        .parallel_ts = 1,
+        .disable_i2c_gate_ctrl = 1,
+        .no_tuner = 1,
+        .if2 = 41500,
+};
+
+static struct zl10353_config anysee_zl10353_tda18212_config = {
+        .demod_address = (0x18 >> 1),
+        .parallel_ts = 1,
+        .disable_i2c_gate_ctrl = 1,
+        .no_tuner = 1,
+        .if2 = 41500,
+};
+
+static struct tda10023_config anysee_tda10023_tda18212_config = {
+        .demod_address = (0x1a >> 1),
+        .xtal   = 16000000,
+        .pll_m  = 12,
+        .pll_p  = 3,
+        .pll_n  = 1,
+        .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_C,
+        .deltaf = 0xba02,
+};
+
+static struct tda18212_config anysee_tda18212_config = {
+        .i2c_address = (0xc0 >> 1),
+        .if_dvbt_6 = 4150,
+        .if_dvbt_7 = 4150,
+        .if_dvbt_8 = 4150,
+        .if_dvbc = 5000,
+};
+
+static struct cx24116_config anysee_cx24116_config = {
+        .demod_address = (0xaa >> 1),
+        .mpg_clk_pos_pol = 0x00,
+        .i2c_wr_max = 48,
+};
+
+static struct stv0900_config anysee_stv0900_config = {
+        .demod_address = (0xd0 >> 1),
+        .demod_mode = 0,
+        .xtal = 8000000,
+        .clkmode = 3,
+        .diseqc_mode = 2,
+        .tun1_maddress = 0,
+        .tun1_adc = 1, /* 1 Vpp */
+        .path1_mode = 3,
+};
+
+static struct stv6110_config anysee_stv6110_config = {
+        .i2c_address = (0xc0 >> 1),
+        .mclk = 16000000,
+        .clk_div = 1,
+};
+
+static struct isl6423_config anysee_isl6423_config = {
+        .current_max = SEC_CURRENT_800m,
+        .curlim  = SEC_CURRENT_LIM_OFF,
+        .mod_extern = 1,
+        .addr = (0x10 >> 1),
+};
+
+/*
+ * New USB device strings: Mfr=1, Product=2, SerialNumber=0
+ * Manufacturer: AMT.CO.KR
+ *
+ * E30 VID=04b4 PID=861f HW=2 FW=2.1 Product=????????
+ * PCB: ?
+ * parts: DNOS404ZH102A(MT352, DTT7579(?))
+ *
+ * E30 VID=04b4 PID=861f HW=2 FW=2.1 "anysee-T(LP)"
+ * PCB: PCB 507T (rev1.61)
+ * parts: DNOS404ZH103A(ZL10353, DTT7579(?))
+ * OEA=0a OEB=00 OEC=00 OED=ff OEE=00
+ * IOA=45 IOB=ff IOC=00 IOD=ff IOE=00
+ *
+ * E30 Plus VID=04b4 PID=861f HW=6 FW=1.0 "anysee"
+ * PCB: 507CD (rev1.1)
+ * parts: DNOS404ZH103A(ZL10353, DTT7579(?)), CST56I01
+ * OEA=80 OEB=00 OEC=00 OED=ff OEE=fe
+ * IOA=4f IOB=ff IOC=00 IOD=06 IOE=01
+ * IOD[0] ZL10353 1=enabled
+ * IOA[7] TS 0=enabled
+ * tuner is not behind ZL10353 I2C-gate (no care if gate disabled or not)
+ *
+ * E30 C Plus VID=04b4 PID=861f HW=10 FW=1.0 "anysee-DC(LP)"
+ * PCB: 507DC (rev0.2)
+ * parts: TDA10023, DTOS403IH102B TM, CST56I01
+ * OEA=80 OEB=00 OEC=00 OED=ff OEE=fe
+ * IOA=4f IOB=ff IOC=00 IOD=26 IOE=01
+ * IOD[0] TDA10023 1=enabled
+ *
+ * E30 S2 Plus VID=04b4 PID=861f HW=11 FW=0.1 "anysee-S2(LP)"
+ * PCB: 507SI (rev2.1)
+ * parts: BS2N10WCC01(CX24116, CX24118), ISL6423, TDA8024
+ * OEA=80 OEB=00 OEC=ff OED=ff OEE=fe
+ * IOA=4d IOB=ff IOC=00 IOD=26 IOE=01
+ * IOD[0] CX24116 1=enabled
+ *
+ * E30 C Plus VID=1c73 PID=861f HW=15 FW=1.2 "anysee-FA(LP)"
+ * PCB: 507FA (rev0.4)
+ * parts: TDA10023, DTOS403IH102B TM, TDA8024
+ * OEA=80 OEB=00 OEC=ff OED=ff OEE=ff
+ * IOA=4d IOB=ff IOC=00 IOD=00 IOE=c0
+ * IOD[5] TDA10023 1=enabled
+ * IOE[0] tuner 1=enabled
+ *
+ * E30 Combo Plus VID=1c73 PID=861f HW=15 FW=1.2 "anysee-FA(LP)"
+ * PCB: 507FA (rev1.1)
+ * parts: ZL10353, TDA10023, DTOS403IH102B TM, TDA8024
+ * OEA=80 OEB=00 OEC=ff OED=ff OEE=ff
+ * IOA=4d IOB=ff IOC=00 IOD=00 IOE=c0
+ * DVB-C:
+ * IOD[5] TDA10023 1=enabled
+ * IOE[0] tuner 1=enabled
+ * DVB-T:
+ * IOD[0] ZL10353 1=enabled
+ * IOE[0] tuner 0=enabled
+ * tuner is behind ZL10353 I2C-gate
+ *
+ * E7 TC VID=1c73 PID=861f HW=18 FW=0.7 AMTCI=0.5 "anysee-E7TC(LP)"
+ * PCB: 508TC (rev0.6)
+ * parts: ZL10353, TDA10023, DNOD44CDH086A(TDA18212)
+ * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
+ * IOA=4d IOB=00 IOC=cc IOD=48 IOE=e4
+ * IOA[7] TS 1=enabled
+ * IOE[4] TDA18212 1=enabled
+ * DVB-C:
+ * IOD[6] ZL10353 0=disabled
+ * IOD[5] TDA10023 1=enabled
+ * IOE[0] IF 1=enabled
+ * DVB-T:
+ * IOD[5] TDA10023 0=disabled
+ * IOD[6] ZL10353 1=enabled
+ * IOE[0] IF 0=enabled
+ *
+ * E7 S2 VID=1c73 PID=861f HW=19 FW=0.4 AMTCI=0.5 "anysee-E7S2(LP)"
+ * PCB: 508S2 (rev0.7)
+ * parts: DNBU10512IST(STV0903, STV6110), ISL6423
+ * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
+ * IOA=4d IOB=00 IOC=c4 IOD=08 IOE=e4
+ * IOA[7] TS 1=enabled
+ * IOE[5] STV0903 1=enabled
+ *
+ * E7 PTC VID=1c73 PID=861f HW=21 FW=0.1 AMTCI=?? "anysee-E7PTC(LP)"
+ * PCB: 508PTC (rev0.5)
+ * parts: ZL10353, TDA10023, DNOD44CDH086A(TDA18212)
+ * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
+ * IOA=4d IOB=00 IOC=cc IOD=48 IOE=e4
+ * IOA[7] TS 1=enabled
+ * IOE[4] TDA18212 1=enabled
+ * DVB-C:
+ * IOD[6] ZL10353 0=disabled
+ * IOD[5] TDA10023 1=enabled
+ * IOE[0] IF 1=enabled
+ * DVB-T:
+ * IOD[5] TDA10023 0=disabled
+ * IOD[6] ZL10353 1=enabled
+ * IOE[0] IF 0=enabled
+ *
+ * E7 S2 VID=1c73 PID=861f HW=22 FW=0.1 AMTCI=?? "anysee-E7PS2(LP)"
+ * PCB: 508PS2 (rev0.4)
+ * parts: DNBU10512IST(STV0903, STV6110), ISL6423
+ * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
+ * IOA=4d IOB=00 IOC=c4 IOD=08 IOE=e4
+ * IOA[7] TS 1=enabled
+ * IOE[5] STV0903 1=enabled
+ */
+
+static int anysee_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        int ret;
+        struct anysee_state *state = adap->dev->priv;
+        u8 hw_info[3];
+        u8 tmp;
+        struct i2c_msg msg[2] = {
+                {
+                        .addr = anysee_tda18212_config.i2c_address,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = "\x00",
+                }, {
+                        .addr = anysee_tda18212_config.i2c_address,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = &tmp,
+                }
+        };
+
+        /* Check which hardware we have.
+         * We must do this call two times to get reliable values (hw bug).
+         */
+        ret = anysee_get_hw_info(adap->dev, hw_info);
+        if (ret)
+                goto error;
+
+        ret = anysee_get_hw_info(adap->dev, hw_info);
+        if (ret)
+                goto error;
+
+        /* Meaning of these info bytes are guessed. */
+        info("firmware version:%d.%d hardware id:%d",
+                hw_info[1], hw_info[2], hw_info[0]);
+
+        state->hw = hw_info[0];
+
+        switch (state->hw) {
+        case ANYSEE_HW_507T: /* 2 */
+                /* E30 */
+
+                /* attach demod */
+                adap->fe = dvb_attach(mt352_attach, &anysee_mt352_config,
+                        &adap->dev->i2c_adap);
+                if (adap->fe)
+                        break;
+
+                /* attach demod */
+                adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
+                        &adap->dev->i2c_adap);
+
+                break;
+        case ANYSEE_HW_507CD: /* 6 */
+                /* E30 Plus */
+
+                /* enable DVB-T demod on IOD[0] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 0), 0x01);
+                if (ret)
+                        goto error;
+
+                /* enable transport stream on IOA[7] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOA, (0 << 7), 0x80);
+                if (ret)
+                        goto error;
+
+                /* attach demod */
+                adap->fe = dvb_attach(zl10353_attach, &anysee_zl10353_config,
+                        &adap->dev->i2c_adap);
+
+                break;
+        case ANYSEE_HW_507DC: /* 10 */
+                /* E30 C Plus */
+
+                /* enable DVB-C demod on IOD[0] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 0), 0x01);
+                if (ret)
+                        goto error;
+
+                /* attach demod */
+                adap->fe = dvb_attach(tda10023_attach, &anysee_tda10023_config,
+                        &adap->dev->i2c_adap, 0x48);
+
+                break;
+        case ANYSEE_HW_507SI: /* 11 */
+                /* E30 S2 Plus */
+
+                /* enable DVB-S/S2 demod on IOD[0] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 0), 0x01);
+                if (ret)
+                        goto error;
+
+                /* attach demod */
+                adap->fe = dvb_attach(cx24116_attach, &anysee_cx24116_config,
+                        &adap->dev->i2c_adap);
+
+                break;
+        case ANYSEE_HW_507FA: /* 15 */
+                /* E30 Combo Plus */
+                /* E30 C Plus */
+
+                /* enable tuner on IOE[4] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 4), 0x10);
+                if (ret)
+                        goto error;
+
+                /* probe TDA18212 */
+                tmp = 0;
+                ret = i2c_transfer(&adap->dev->i2c_adap, msg, 2);
+                if (ret == 2 && tmp == 0xc7)
+                        deb_info("%s: TDA18212 found\n", __func__);
+                else
+                        tmp = 0;
+
+                /* disable tuner on IOE[4] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (0 << 4), 0x10);
+                if (ret)
+                        goto error;
+
+                if (dvb_usb_anysee_delsys) {
+                        /* disable DVB-C demod on IOD[5] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (0 << 5),
+                                0x20);
+                        if (ret)
+                                goto error;
+
+                        /* enable DVB-T demod on IOD[0] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 0),
+                                0x01);
+                        if (ret)
+                                goto error;
+
+                        /* attach demod */
+                        if (tmp == 0xc7) {
+                                /* TDA18212 config */
+                                adap->fe = dvb_attach(zl10353_attach,
+                                        &anysee_zl10353_tda18212_config2,
+                                        &adap->dev->i2c_adap);
+                        } else {
+                                /* PLL config */
+                                adap->fe = dvb_attach(zl10353_attach,
+                                        &anysee_zl10353_config,
+                                        &adap->dev->i2c_adap);
+                        }
+                } else {
+                        /* disable DVB-T demod on IOD[0] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (0 << 0),
+                                0x01);
+                        if (ret)
+                                goto error;
+
+                        /* enable DVB-C demod on IOD[5] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 5),
+                                0x20);
+                        if (ret)
+                                goto error;
+
+                        /* attach demod */
+                        if (tmp == 0xc7) {
+                                /* TDA18212 config */
+                                adap->fe = dvb_attach(tda10023_attach,
+                                        &anysee_tda10023_tda18212_config,
+                                        &adap->dev->i2c_adap, 0x48);
+                        } else {
+                                /* PLL config */
+                                adap->fe = dvb_attach(tda10023_attach,
+                                        &anysee_tda10023_config,
+                                        &adap->dev->i2c_adap, 0x48);
+                        }
+                }
+
+                break;
+        case ANYSEE_HW_508TC: /* 18 */
+        case ANYSEE_HW_508PTC: /* 21 */
+                /* E7 TC */
+                /* E7 PTC */
+
+                /* enable transport stream on IOA[7] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOA, (1 << 7), 0x80);
+                if (ret)
+                        goto error;
+
+                if (dvb_usb_anysee_delsys) {
+                        /* disable DVB-C demod on IOD[5] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (0 << 5),
+                                0x20);
+                        if (ret)
+                                goto error;
+
+                        /* enable DVB-T demod on IOD[6] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 6),
+                                0x40);
+                        if (ret)
+                                goto error;
+
+                        /* enable IF route on IOE[0] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (0 << 0),
+                                0x01);
+                        if (ret)
+                                goto error;
+
+                        /* attach demod */
+                        adap->fe = dvb_attach(zl10353_attach,
+                                &anysee_zl10353_tda18212_config,
+                                &adap->dev->i2c_adap);
+                } else {
+                        /* disable DVB-T demod on IOD[6] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (0 << 6),
+                                0x40);
+                        if (ret)
+                                goto error;
+
+                        /* enable DVB-C demod on IOD[5] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOD, (1 << 5),
+                                0x20);
+                        if (ret)
+                                goto error;
+
+                        /* enable IF route on IOE[0] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 0),
+                                0x01);
+                        if (ret)
+                                goto error;
+
+                        /* attach demod */
+                        adap->fe = dvb_attach(tda10023_attach,
+                                &anysee_tda10023_tda18212_config,
+                                &adap->dev->i2c_adap, 0x48);
+                }
+
+                break;
+        case ANYSEE_HW_508S2: /* 19 */
+        case ANYSEE_HW_508PS2: /* 22 */
+                /* E7 S2 */
+                /* E7 PS2 */
+
+                /* enable transport stream on IOA[7] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOA, (1 << 7), 0x80);
+                if (ret)
+                        goto error;
+
+                /* enable DVB-S/S2 demod on IOE[5] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 5), 0x20);
+                if (ret)
+                        goto error;
+
+                /* attach demod */
+                adap->fe = dvb_attach(stv0900_attach, &anysee_stv0900_config,
+                        &adap->dev->i2c_adap, 0);
+
+                break;
+        }
+
+        if (!adap->fe) {
+                /* we have no frontend :-( */
+                ret = -ENODEV;
+                err("Unsupported Anysee version. " \
+                        "Please report the <linux-media@vger.kernel.org>.");
+        }
+error:
+        return ret;
+}
+
+static int anysee_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct anysee_state *state = adap->dev->priv;
+        struct dvb_frontend *fe;
+        int ret;
+        deb_info("%s:\n", __func__);
+
+        switch (state->hw) {
+        case ANYSEE_HW_507T: /* 2 */
+                /* E30 */
+
+                /* attach tuner */
+                fe = dvb_attach(dvb_pll_attach, adap->fe, (0xc2 >> 1),
+                        NULL, DVB_PLL_THOMSON_DTT7579);
+
+                break;
+        case ANYSEE_HW_507CD: /* 6 */
+                /* E30 Plus */
+
+                /* attach tuner */
+                fe = dvb_attach(dvb_pll_attach, adap->fe, (0xc2 >> 1),
+                        &adap->dev->i2c_adap, DVB_PLL_THOMSON_DTT7579);
+
+                break;
+        case ANYSEE_HW_507DC: /* 10 */
+                /* E30 C Plus */
+
+                /* attach tuner */
+                fe = dvb_attach(dvb_pll_attach, adap->fe, (0xc0 >> 1),
+                        &adap->dev->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
+
+                break;
+        case ANYSEE_HW_507SI: /* 11 */
+                /* E30 S2 Plus */
+
+                /* attach LNB controller */
+                fe = dvb_attach(isl6423_attach, adap->fe, &adap->dev->i2c_adap,
+                        &anysee_isl6423_config);
+
+                break;
+        case ANYSEE_HW_507FA: /* 15 */
+                /* E30 Combo Plus */
+                /* E30 C Plus */
+
+                if (dvb_usb_anysee_delsys) {
+                        /* enable DVB-T tuner on IOE[0] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (0 << 0),
+                                0x01);
+                        if (ret)
+                                goto error;
+                } else {
+                        /* enable DVB-C tuner on IOE[0] */
+                        ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 0),
+                                0x01);
+                        if (ret)
+                                goto error;
+                }
+
+                /* Try first attach TDA18212 silicon tuner on IOE[4], if that
+                 * fails attach old simple PLL. */
+
+                /* enable tuner on IOE[4] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 4), 0x10);
+                if (ret)
+                        goto error;
+
+                /* attach tuner */
+                fe = dvb_attach(tda18212_attach, adap->fe, &adap->dev->i2c_adap,
+                        &anysee_tda18212_config);
+                if (fe)
+                        break;
+
+                /* disable tuner on IOE[4] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (0 << 4), 0x10);
+                if (ret)
+                        goto error;
+
+                /* attach tuner */
+                fe = dvb_attach(dvb_pll_attach, adap->fe, (0xc0 >> 1),
+                        &adap->dev->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
+
+                break;
+        case ANYSEE_HW_508TC: /* 18 */
+        case ANYSEE_HW_508PTC: /* 21 */
+                /* E7 TC */
+                /* E7 PTC */
+
+                /* enable tuner on IOE[4] */
+                ret = anysee_wr_reg_mask(adap->dev, REG_IOE, (1 << 4), 0x10);
+                if (ret)
+                        goto error;
+
+                /* attach tuner */
+                fe = dvb_attach(tda18212_attach, adap->fe, &adap->dev->i2c_adap,
+                        &anysee_tda18212_config);
+
+                break;
+        case ANYSEE_HW_508S2: /* 19 */
+        case ANYSEE_HW_508PS2: /* 22 */
+                /* E7 S2 */
+                /* E7 PS2 */
+
+                /* attach tuner */
+                fe = dvb_attach(stv6110_attach, adap->fe,
+                        &anysee_stv6110_config, &adap->dev->i2c_adap);
+
+                if (fe) {
+                        /* attach LNB controller */
+                        fe = dvb_attach(isl6423_attach, adap->fe,
+                                &adap->dev->i2c_adap, &anysee_isl6423_config);
+                }
+
+                break;
+        default:
+                fe = NULL;
+        }
+
+        if (fe)
+                ret = 0;
+        else
+                ret = -ENODEV;
+
+error:
+        return ret;
+}
+
+static int anysee_rc_query(struct dvb_usb_device *d)
+{
+        u8 buf[] = {CMD_GET_IR_CODE};
+        u8 ircode[2];
+        int ret;
+
+        /* Remote controller is basic NEC using address byte 0x08.
+           Anysee device RC query returns only two bytes, status and code,
+           address byte is dropped. Also it does not return any value for
+           NEC RCs having address byte other than 0x08. Due to that, we
+           cannot use that device as standard NEC receiver.
+           It could be possible make hack which reads whole code directly
+           from device memory... */
+
+        ret = anysee_ctrl_msg(d, buf, sizeof(buf), ircode, sizeof(ircode));
+        if (ret)
+                return ret;
+
+        if (ircode[0]) {
+                deb_rc("%s: key pressed %02x\n", __func__, ircode[1]);
+                rc_keydown(d->rc_dev, 0x08 << 8 | ircode[1], 0);
+        }
+
+        return 0;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties anysee_properties;
+
+static int anysee_probe(struct usb_interface *intf,
+                        const struct usb_device_id *id)
+{
+        struct dvb_usb_device *d;
+        struct usb_host_interface *alt;
+        int ret;
+
+        /* There is one interface with two alternate settings.
+           Alternate setting 0 is for bulk transfer.
+           Alternate setting 1 is for isochronous transfer.
+           We use bulk transfer (alternate setting 0). */
+        if (intf->num_altsetting < 1)
+                return -ENODEV;
+
+        /*
+         * Anysee is always warm (its USB-bridge, Cypress FX2, uploads
+         * firmware from eeprom).  If dvb_usb_device_init() succeeds that
+         * means d is a valid pointer.
+         */
+        ret = dvb_usb_device_init(intf, &anysee_properties, THIS_MODULE, &d,
+                adapter_nr);
+        if (ret)
+                return ret;
+
+        alt = usb_altnum_to_altsetting(intf, 0);
+        if (alt == NULL) {
+                deb_info("%s: no alt found!\n", __func__);
+                return -ENODEV;
+        }
+
+        ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
+                alt->desc.bAlternateSetting);
+        if (ret)
+                return ret;
+
+        return anysee_init(d);
+}
+
+static struct usb_device_id anysee_table[] = {
+        { USB_DEVICE(USB_VID_CYPRESS, USB_PID_ANYSEE) },
+        { USB_DEVICE(USB_VID_AMT,     USB_PID_ANYSEE) },
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, anysee_table);
+
+static struct dvb_usb_device_properties anysee_properties = {
+        .caps             = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl         = DEVICE_SPECIFIC,
+
+        .size_of_priv     = sizeof(struct anysee_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = anysee_streaming_ctrl,
+                        .frontend_attach  = anysee_frontend_attach,
+                        .tuner_attach     = anysee_tuner_attach,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 8,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = (16*512),
+                                        }
+                                }
+                        },
+                }
+        },
+
+        .rc.core = {
+                .rc_codes         = RC_MAP_ANYSEE,
+                .protocol         = RC_TYPE_OTHER,
+                .module_name      = "anysee",
+                .rc_query         = anysee_rc_query,
+                .rc_interval      = 250,  /* windows driver uses 500ms */
+        },
+
+        .i2c_algo         = &anysee_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 1,
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        .name = "Anysee DVB USB2.0",
+                        .cold_ids = {NULL},
+                        .warm_ids = {&anysee_table[0],
+                                     &anysee_table[1], NULL},
+                },
+        }
+};
+
+static struct usb_driver anysee_driver = {
+        .name       = "dvb_usb_anysee",
+        .probe      = anysee_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table   = anysee_table,
+};
+
+/* module stuff */
+static int __init anysee_module_init(void)
+{
+        int ret;
+
+        ret = usb_register(&anysee_driver);
+        if (ret)
+                err("%s: usb_register failed. Error number %d", __func__, ret);
+
+        return ret;
+}
+
+static void __exit anysee_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&anysee_driver);
+}
+
+module_init(anysee_module_init);
+module_exit(anysee_module_exit);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("Driver Anysee E30 DVB-C & DVB-T USB2.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/anysee.h b/drivers/media/dvb/dvb-usb/anysee.h
new file mode 100644
index 00000000000..ad6ccd1ea2d
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/anysee.h
@@ -0,0 +1,325 @@
+/*
+ * DVB USB Linux driver for Anysee E30 DVB-C & DVB-T USB2.0 receiver
+ *
+ * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
+ *
+ *    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.
+ *
+ * TODO:
+ * - add smart card reader support for Conditional Access (CA)
+ *
+ * Card reader in Anysee is nothing more than ISO 7816 card reader.
+ * There is no hardware CAM in any Anysee device sold.
+ * In my understanding it should be implemented by making own module
+ * for ISO 7816 card reader, like dvb_ca_en50221 is implemented. This
+ * module registers serial interface that can be used to communicate
+ * with any ISO 7816 smart card.
+ *
+ * Any help according to implement serial smart card reader support
+ * is highly welcome!
+ */
+
+#ifndef _DVB_USB_ANYSEE_H_
+#define _DVB_USB_ANYSEE_H_
+
+#define DVB_USB_LOG_PREFIX "anysee"
+#include "dvb-usb.h"
+
+#define deb_info(args...) dprintk(dvb_usb_anysee_debug, 0x01, args)
+#define deb_xfer(args...) dprintk(dvb_usb_anysee_debug, 0x02, args)
+#define deb_rc(args...)   dprintk(dvb_usb_anysee_debug, 0x04, args)
+#define deb_reg(args...)  dprintk(dvb_usb_anysee_debug, 0x08, args)
+#define deb_i2c(args...)  dprintk(dvb_usb_anysee_debug, 0x10, args)
+#define deb_fw(args...)   dprintk(dvb_usb_anysee_debug, 0x20, args)
+
+enum cmd {
+        CMD_I2C_READ            = 0x33,
+        CMD_I2C_WRITE           = 0x31,
+        CMD_REG_READ            = 0xb0,
+        CMD_REG_WRITE           = 0xb1,
+        CMD_STREAMING_CTRL      = 0x12,
+        CMD_LED_AND_IR_CTRL     = 0x16,
+        CMD_GET_IR_CODE         = 0x41,
+        CMD_GET_HW_INFO         = 0x19,
+        CMD_SMARTCARD           = 0x34,
+};
+
+struct anysee_state {
+        u8 hw; /* PCB ID */
+        u8 seq;
+};
+
+#define ANYSEE_HW_507T    2 /* E30 */
+#define ANYSEE_HW_507CD   6 /* E30 Plus */
+#define ANYSEE_HW_507DC  10 /* E30 C Plus */
+#define ANYSEE_HW_507SI  11 /* E30 S2 Plus */
+#define ANYSEE_HW_507FA  15 /* E30 Combo Plus / E30 C Plus */
+#define ANYSEE_HW_508TC  18 /* E7 TC */
+#define ANYSEE_HW_508S2  19 /* E7 S2 */
+#define ANYSEE_HW_508PTC 21 /* E7 PTC Plus */
+#define ANYSEE_HW_508PS2 22 /* E7 PS2 Plus */
+
+#define REG_IOA       0x80 /* Port A (bit addressable) */
+#define REG_IOB       0x90 /* Port B (bit addressable) */
+#define REG_IOC       0xa0 /* Port C (bit addressable) */
+#define REG_IOD       0xb0 /* Port D (bit addressable) */
+#define REG_IOE       0xb1 /* Port E (NOT bit addressable) */
+#define REG_OEA       0xb2 /* Port A Output Enable */
+#define REG_OEB       0xb3 /* Port B Output Enable */
+#define REG_OEC       0xb4 /* Port C Output Enable */
+#define REG_OED       0xb5 /* Port D Output Enable */
+#define REG_OEE       0xb6 /* Port E Output Enable */
+
+#endif
+
+/***************************************************************************
+ * USB API description (reverse engineered)
+ ***************************************************************************
+
+Transaction flow:
+=================
+BULK[00001] >>> REQUEST PACKET 64 bytes
+BULK[00081] <<< REPLY PACKET #1 64 bytes (PREVIOUS TRANSACTION REPLY)
+BULK[00081] <<< REPLY PACKET #2 64 bytes (CURRENT TRANSACTION REPLY)
+
+General reply packet(s) are always used if not own reply defined.
+
+============================================================================
+| 00-63 | GENERAL REPLY PACKET #1 (PREVIOUS REPLY)
+============================================================================
+|    00 | reply data (if any) from previous transaction
+|       | Just same reply packet as returned during previous transaction.
+|       | Needed only if reply is missed in previous transaction.
+|       | Just skip normally.
+----------------------------------------------------------------------------
+| 01-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | GENERAL REPLY PACKET #2 (CURRENT REPLY)
+============================================================================
+|    00 | reply data (if any)
+----------------------------------------------------------------------------
+| 01-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | I2C WRITE REQUEST PACKET
+============================================================================
+|    00 | 0x31 I2C write command
+----------------------------------------------------------------------------
+|    01 | i2c address
+----------------------------------------------------------------------------
+|    02 | data length
+|       | 0x02 (for typical I2C reg / val pair)
+----------------------------------------------------------------------------
+|    03 | 0x01
+----------------------------------------------------------------------------
+| 04-   | data
+----------------------------------------------------------------------------
+|   -59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | I2C READ REQUEST PACKET
+============================================================================
+|    00 | 0x33 I2C read command
+----------------------------------------------------------------------------
+|    01 | i2c address + 1
+----------------------------------------------------------------------------
+|    02 | register
+----------------------------------------------------------------------------
+|    03 | 0x00
+----------------------------------------------------------------------------
+|    04 | 0x00
+----------------------------------------------------------------------------
+|    05 | data length
+----------------------------------------------------------------------------
+| 06-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | USB CONTROLLER REGISTER WRITE REQUEST PACKET
+============================================================================
+|    00 | 0xb1 register write command
+----------------------------------------------------------------------------
+| 01-02 | register
+----------------------------------------------------------------------------
+|    03 | 0x01
+----------------------------------------------------------------------------
+|    04 | value
+----------------------------------------------------------------------------
+| 05-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | USB CONTROLLER REGISTER READ REQUEST PACKET
+============================================================================
+|    00 | 0xb0 register read command
+----------------------------------------------------------------------------
+| 01-02 | register
+----------------------------------------------------------------------------
+|    03 | 0x01
+----------------------------------------------------------------------------
+| 04-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | LED CONTROL REQUEST PACKET
+============================================================================
+|    00 | 0x16 LED and IR control command
+----------------------------------------------------------------------------
+|    01 | 0x01 (LED)
+----------------------------------------------------------------------------
+|    03 | 0x00 blink
+|       | 0x01 lights continuously
+----------------------------------------------------------------------------
+|    04 | blink interval
+|       | 0x00 fastest (looks like LED lights continuously)
+|       | 0xff slowest
+----------------------------------------------------------------------------
+| 05-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | IR CONTROL REQUEST PACKET
+============================================================================
+|    00 | 0x16 LED and IR control command
+----------------------------------------------------------------------------
+|    01 | 0x02 (IR)
+----------------------------------------------------------------------------
+|    03 | 0x00 IR disabled
+|       | 0x01 IR enabled
+----------------------------------------------------------------------------
+| 04-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | STREAMING CONTROL REQUEST PACKET
+============================================================================
+|    00 | 0x12 streaming control command
+----------------------------------------------------------------------------
+|    01 | 0x00 streaming disabled
+|       | 0x01 streaming enabled
+----------------------------------------------------------------------------
+|    02 | 0x00
+----------------------------------------------------------------------------
+| 03-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | REMOTE CONTROL REQUEST PACKET
+============================================================================
+|    00 | 0x41 remote control command
+----------------------------------------------------------------------------
+| 01-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | REMOTE CONTROL REPLY PACKET
+============================================================================
+|    00 | 0x00 code not received
+|       | 0x01 code received
+----------------------------------------------------------------------------
+|    01 | remote control code
+----------------------------------------------------------------------------
+| 02-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | GET HARDWARE INFO REQUEST PACKET
+============================================================================
+|    00 | 0x19 get hardware info command
+----------------------------------------------------------------------------
+| 01-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | GET HARDWARE INFO REPLY PACKET
+============================================================================
+|    00 | hardware id
+----------------------------------------------------------------------------
+| 01-02 | firmware version
+----------------------------------------------------------------------------
+| 03-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+============================================================================
+| 00-63 | SMART CARD READER PACKET
+============================================================================
+|    00 | 0x34 smart card reader command
+----------------------------------------------------------------------------
+|    xx |
+----------------------------------------------------------------------------
+| xx-59 | don't care
+----------------------------------------------------------------------------
+|    60 | packet sequence number
+----------------------------------------------------------------------------
+| 61-63 | don't care
+----------------------------------------------------------------------------
+
+*/
diff --git a/drivers/media/dvb/dvb-usb/au6610.c b/drivers/media/dvb/dvb-usb/au6610.c
new file mode 100644
index 00000000000..2351077ff2b
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/au6610.c
@@ -0,0 +1,268 @@
+/*
+ * DVB USB Linux driver for Alcor Micro AU6610 DVB-T USB2.0.
+ *
+ * Copyright (C) 2006 Antti Palosaari <crope@iki.fi>
+ *
+ *    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 "au6610.h"
+#include "zl10353.h"
+#include "qt1010.h"
+
+/* debug */
+static int dvb_usb_au6610_debug;
+module_param_named(debug, dvb_usb_au6610_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int au6610_usb_msg(struct dvb_usb_device *d, u8 operation, u8 addr,
+                          u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        int ret;
+        u16 index;
+        u8 *usb_buf;
+
+        /*
+         * allocate enough for all known requests,
+         * read returns 5 and write 6 bytes
+         */
+        usb_buf = kmalloc(6, GFP_KERNEL);
+        if (!usb_buf)
+                return -ENOMEM;
+
+        switch (wlen) {
+        case 1:
+                index = wbuf[0] << 8;
+                break;
+        case 2:
+                index = wbuf[0] << 8;
+                index += wbuf[1];
+                break;
+        default:
+                warn("wlen = %x, aborting.", wlen);
+                ret = -EINVAL;
+                goto error;
+        }
+
+        ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0), operation,
+                              USB_TYPE_VENDOR|USB_DIR_IN, addr << 1, index,
+                              usb_buf, 6, AU6610_USB_TIMEOUT);
+        if (ret < 0)
+                goto error;
+
+        switch (operation) {
+        case AU6610_REQ_I2C_READ:
+        case AU6610_REQ_USB_READ:
+                /* requested value is always 5th byte in buffer */
+                rbuf[0] = usb_buf[4];
+        }
+error:
+        kfree(usb_buf);
+        return ret;
+}
+
+static int au6610_i2c_msg(struct dvb_usb_device *d, u8 addr,
+                          u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        u8 request;
+        u8 wo = (rbuf == NULL || rlen == 0); /* write-only */
+
+        if (wo) {
+                request = AU6610_REQ_I2C_WRITE;
+        } else { /* rw */
+                request = AU6610_REQ_I2C_READ;
+        }
+
+        return au6610_usb_msg(d, request, addr, wbuf, wlen, rbuf, rlen);
+}
+
+
+/* I2C */
+static int au6610_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                           int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i;
+
+        if (num > 2)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                /* write/read request */
+                if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
+                        if (au6610_i2c_msg(d, msg[i].addr, msg[i].buf,
+                                           msg[i].len, msg[i+1].buf,
+                                           msg[i+1].len) < 0)
+                                break;
+                        i++;
+                } else if (au6610_i2c_msg(d, msg[i].addr, msg[i].buf,
+                                               msg[i].len, NULL, 0) < 0)
+                                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+
+static u32 au6610_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm au6610_i2c_algo = {
+        .master_xfer   = au6610_i2c_xfer,
+        .functionality = au6610_i2c_func,
+};
+
+/* Callbacks for DVB USB */
+static struct zl10353_config au6610_zl10353_config = {
+        .demod_address = 0x0f,
+        .no_tuner = 1,
+        .parallel_ts = 1,
+};
+
+static int au6610_zl10353_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        adap->fe = dvb_attach(zl10353_attach, &au6610_zl10353_config,
+                &adap->dev->i2c_adap);
+        if (adap->fe == NULL)
+                return -ENODEV;
+
+        return 0;
+}
+
+static struct qt1010_config au6610_qt1010_config = {
+        .i2c_address = 0x62
+};
+
+static int au6610_qt1010_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        return dvb_attach(qt1010_attach,
+                          adap->fe, &adap->dev->i2c_adap,
+                          &au6610_qt1010_config) == NULL ? -ENODEV : 0;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties au6610_properties;
+
+static int au6610_probe(struct usb_interface *intf,
+                        const struct usb_device_id *id)
+{
+        struct dvb_usb_device *d;
+        struct usb_host_interface *alt;
+        int ret;
+
+        if (intf->num_altsetting < AU6610_ALTSETTING_COUNT)
+                return -ENODEV;
+
+        ret = dvb_usb_device_init(intf, &au6610_properties, THIS_MODULE, &d,
+                                  adapter_nr);
+        if (ret == 0) {
+                alt = usb_altnum_to_altsetting(intf, AU6610_ALTSETTING);
+
+                if (alt == NULL) {
+                        deb_info("%s: no alt found!\n", __func__);
+                        return -ENODEV;
+                }
+                ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
+                                        alt->desc.bAlternateSetting);
+        }
+
+        return ret;
+}
+
+static struct usb_device_id au6610_table [] = {
+        { USB_DEVICE(USB_VID_ALCOR_MICRO, USB_PID_SIGMATEK_DVB_110) },
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, au6610_table);
+
+static struct dvb_usb_device_properties au6610_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+
+        .size_of_priv = 0,
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .frontend_attach  = au6610_zl10353_frontend_attach,
+                        .tuner_attach     = au6610_qt1010_tuner_attach,
+
+                        .stream = {
+                                .type = USB_ISOC,
+                                .count = 5,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .isoc = {
+                                                .framesperurb = 40,
+                                                .framesize = 942,
+                                                .interval = 1,
+                                        }
+                                }
+                        },
+                }
+        },
+
+        .i2c_algo = &au6610_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        .name = "Sigmatek DVB-110 DVB-T USB2.0",
+                        .cold_ids = {NULL},
+                        .warm_ids = {&au6610_table[0], NULL},
+                },
+        }
+};
+
+static struct usb_driver au6610_driver = {
+        .name       = "dvb_usb_au6610",
+        .probe      = au6610_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table   = au6610_table,
+};
+
+/* module stuff */
+static int __init au6610_module_init(void)
+{
+        int ret;
+
+        ret = usb_register(&au6610_driver);
+        if (ret)
+                err("usb_register failed. Error number %d", ret);
+
+        return ret;
+}
+
+static void __exit au6610_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&au6610_driver);
+}
+
+module_init(au6610_module_init);
+module_exit(au6610_module_exit);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("Driver for Alcor Micro AU6610 DVB-T USB2.0");
+MODULE_VERSION("0.1");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/au6610.h b/drivers/media/dvb/dvb-usb/au6610.h
new file mode 100644
index 00000000000..7849abe2c61
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/au6610.h
@@ -0,0 +1,39 @@
+/*
+ * DVB USB Linux driver for Alcor Micro AU6610 DVB-T USB2.0.
+ *
+ * Copyright (C) 2006 Antti Palosaari <crope@iki.fi>
+ *
+ *    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_USB_AU6610_H_
+#define _DVB_USB_AU6610_H_
+
+#define DVB_USB_LOG_PREFIX "au6610"
+#include "dvb-usb.h"
+
+#define deb_info(args...)   dprintk(dvb_usb_au6610_debug, 0x01, args)
+
+#define AU6610_REQ_I2C_WRITE    0x14
+#define AU6610_REQ_I2C_READ     0x13
+#define AU6610_REQ_USB_WRITE    0x16
+#define AU6610_REQ_USB_READ     0x15
+
+#define AU6610_USB_TIMEOUT 1000
+
+#define AU6610_ALTSETTING_COUNT 6
+#define AU6610_ALTSETTING       5
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/az6027.c b/drivers/media/dvb/dvb-usb/az6027.c
new file mode 100644
index 00000000000..57e2444d51a
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/az6027.c
@@ -0,0 +1,1203 @@
+/* DVB USB compliant Linux driver for the AZUREWAVE DVB-S/S2 USB2.0 (AZ6027)
+ * receiver.
+ *
+ * Copyright (C) 2009 Adams.Xu <adams.xu@azwave.com.cn>
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "az6027.h"
+
+#include "stb0899_drv.h"
+#include "stb0899_reg.h"
+#include "stb0899_cfg.h"
+
+#include "stb6100.h"
+#include "stb6100_cfg.h"
+#include "dvb_ca_en50221.h"
+
+int dvb_usb_az6027_debug;
+module_param_named(debug, dvb_usb_az6027_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+struct az6027_device_state {
+        struct dvb_ca_en50221 ca;
+        struct mutex ca_mutex;
+        u8 power_state;
+};
+
+static const struct stb0899_s1_reg az6027_stb0899_s1_init_1[] = {
+
+        /* 0x0000000b, SYSREG */
+        { STB0899_DEV_ID                , 0x30 },
+        { STB0899_DISCNTRL1             , 0x32 },
+        { STB0899_DISCNTRL2             , 0x80 },
+        { STB0899_DISRX_ST0             , 0x04 },
+        { STB0899_DISRX_ST1             , 0x00 },
+        { STB0899_DISPARITY             , 0x00 },
+        { STB0899_DISFIFO               , 0x00 },
+        { STB0899_DISSTATUS             , 0x20 },
+        { STB0899_DISF22                , 0x99 },
+        { STB0899_DISF22RX              , 0xa8 },
+        /* SYSREG ? */
+        { STB0899_ACRPRESC              , 0x11 },
+        { STB0899_ACRDIV1               , 0x0a },
+        { STB0899_ACRDIV2               , 0x05 },
+        { STB0899_DACR1                 , 0x00 },
+        { STB0899_DACR2                 , 0x00 },
+        { STB0899_OUTCFG                , 0x00 },
+        { STB0899_MODECFG               , 0x00 },
+        { STB0899_IRQSTATUS_3           , 0xfe },
+        { STB0899_IRQSTATUS_2           , 0x03 },
+        { STB0899_IRQSTATUS_1           , 0x7c },
+        { STB0899_IRQSTATUS_0           , 0xf4 },
+        { STB0899_IRQMSK_3              , 0xf3 },
+        { STB0899_IRQMSK_2              , 0xfc },
+        { STB0899_IRQMSK_1              , 0xff },
+        { STB0899_IRQMSK_0              , 0xff },
+        { STB0899_IRQCFG                , 0x00 },
+        { STB0899_I2CCFG                , 0x88 },
+        { STB0899_I2CRPT                , 0x58 },
+        { STB0899_IOPVALUE5             , 0x00 },
+        { STB0899_IOPVALUE4             , 0x33 },
+        { STB0899_IOPVALUE3             , 0x6d },
+        { STB0899_IOPVALUE2             , 0x90 },
+        { STB0899_IOPVALUE1             , 0x60 },
+        { STB0899_IOPVALUE0             , 0x00 },
+        { STB0899_GPIO00CFG             , 0x82 },
+        { STB0899_GPIO01CFG             , 0x82 },
+        { STB0899_GPIO02CFG             , 0x82 },
+        { STB0899_GPIO03CFG             , 0x82 },
+        { STB0899_GPIO04CFG             , 0x82 },
+        { STB0899_GPIO05CFG             , 0x82 },
+        { STB0899_GPIO06CFG             , 0x82 },
+        { STB0899_GPIO07CFG             , 0x82 },
+        { STB0899_GPIO08CFG             , 0x82 },
+        { STB0899_GPIO09CFG             , 0x82 },
+        { STB0899_GPIO10CFG             , 0x82 },
+        { STB0899_GPIO11CFG             , 0x82 },
+        { STB0899_GPIO12CFG             , 0x82 },
+        { STB0899_GPIO13CFG             , 0x82 },
+        { STB0899_GPIO14CFG             , 0x82 },
+        { STB0899_GPIO15CFG             , 0x82 },
+        { STB0899_GPIO16CFG             , 0x82 },
+        { STB0899_GPIO17CFG             , 0x82 },
+        { STB0899_GPIO18CFG             , 0x82 },
+        { STB0899_GPIO19CFG             , 0x82 },
+        { STB0899_GPIO20CFG             , 0x82 },
+        { STB0899_SDATCFG               , 0xb8 },
+        { STB0899_SCLTCFG               , 0xba },
+        { STB0899_AGCRFCFG              , 0x1c }, /* 0x11 */
+        { STB0899_GPIO22                , 0x82 }, /* AGCBB2CFG */
+        { STB0899_GPIO21                , 0x91 }, /* AGCBB1CFG */
+        { STB0899_DIRCLKCFG             , 0x82 },
+        { STB0899_CLKOUT27CFG           , 0x7e },
+        { STB0899_STDBYCFG              , 0x82 },
+        { STB0899_CS0CFG                , 0x82 },
+        { STB0899_CS1CFG                , 0x82 },
+        { STB0899_DISEQCOCFG            , 0x20 },
+        { STB0899_GPIO32CFG             , 0x82 },
+        { STB0899_GPIO33CFG             , 0x82 },
+        { STB0899_GPIO34CFG             , 0x82 },
+        { STB0899_GPIO35CFG             , 0x82 },
+        { STB0899_GPIO36CFG             , 0x82 },
+        { STB0899_GPIO37CFG             , 0x82 },
+        { STB0899_GPIO38CFG             , 0x82 },
+        { STB0899_GPIO39CFG             , 0x82 },
+        { STB0899_NCOARSE               , 0x17 }, /* 0x15 = 27 Mhz Clock, F/3 = 198MHz, F/6 = 99MHz */
+        { STB0899_SYNTCTRL              , 0x02 }, /* 0x00 = CLK from CLKI, 0x02 = CLK from XTALI */
+        { STB0899_FILTCTRL              , 0x00 },
+        { STB0899_SYSCTRL               , 0x01 },
+        { STB0899_STOPCLK1              , 0x20 },
+        { STB0899_STOPCLK2              , 0x00 },
+        { STB0899_INTBUFSTATUS          , 0x00 },
+        { STB0899_INTBUFCTRL            , 0x0a },
+        { 0xffff                        , 0xff },
+};
+
+static const struct stb0899_s1_reg az6027_stb0899_s1_init_3[] = {
+        { STB0899_DEMOD                 , 0x00 },
+        { STB0899_RCOMPC                , 0xc9 },
+        { STB0899_AGC1CN                , 0x01 },
+        { STB0899_AGC1REF               , 0x10 },
+        { STB0899_RTC                   , 0x23 },
+        { STB0899_TMGCFG                , 0x4e },
+        { STB0899_AGC2REF               , 0x34 },
+        { STB0899_TLSR                  , 0x84 },
+        { STB0899_CFD                   , 0xf7 },
+        { STB0899_ACLC                  , 0x87 },
+        { STB0899_BCLC                  , 0x94 },
+        { STB0899_EQON                  , 0x41 },
+        { STB0899_LDT                   , 0xf1 },
+        { STB0899_LDT2                  , 0xe3 },
+        { STB0899_EQUALREF              , 0xb4 },
+        { STB0899_TMGRAMP               , 0x10 },
+        { STB0899_TMGTHD                , 0x30 },
+        { STB0899_IDCCOMP               , 0xfd },
+        { STB0899_QDCCOMP               , 0xff },
+        { STB0899_POWERI                , 0x0c },
+        { STB0899_POWERQ                , 0x0f },
+        { STB0899_RCOMP                 , 0x6c },
+        { STB0899_AGCIQIN               , 0x80 },
+        { STB0899_AGC2I1                , 0x06 },
+        { STB0899_AGC2I2                , 0x00 },
+        { STB0899_TLIR                  , 0x30 },
+        { STB0899_RTF                   , 0x7f },
+        { STB0899_DSTATUS               , 0x00 },
+        { STB0899_LDI                   , 0xbc },
+        { STB0899_CFRM                  , 0xea },
+        { STB0899_CFRL                  , 0x31 },
+        { STB0899_NIRM                  , 0x2b },
+        { STB0899_NIRL                  , 0x80 },
+        { STB0899_ISYMB                 , 0x1d },
+        { STB0899_QSYMB                 , 0xa6 },
+        { STB0899_SFRH                  , 0x2f },
+        { STB0899_SFRM                  , 0x68 },
+        { STB0899_SFRL                  , 0x40 },
+        { STB0899_SFRUPH                , 0x2f },
+        { STB0899_SFRUPM                , 0x68 },
+        { STB0899_SFRUPL                , 0x40 },
+        { STB0899_EQUAI1                , 0x02 },
+        { STB0899_EQUAQ1                , 0xff },
+        { STB0899_EQUAI2                , 0x04 },
+        { STB0899_EQUAQ2                , 0x05 },
+        { STB0899_EQUAI3                , 0x02 },
+        { STB0899_EQUAQ3                , 0xfd },
+        { STB0899_EQUAI4                , 0x03 },
+        { STB0899_EQUAQ4                , 0x07 },
+        { STB0899_EQUAI5                , 0x08 },
+        { STB0899_EQUAQ5                , 0xf5 },
+        { STB0899_DSTATUS2              , 0x00 },
+        { STB0899_VSTATUS               , 0x00 },
+        { STB0899_VERROR                , 0x86 },
+        { STB0899_IQSWAP                , 0x2a },
+        { STB0899_ECNT1M                , 0x00 },
+        { STB0899_ECNT1L                , 0x00 },
+        { STB0899_ECNT2M                , 0x00 },
+        { STB0899_ECNT2L                , 0x00 },
+        { STB0899_ECNT3M                , 0x0a },
+        { STB0899_ECNT3L                , 0xad },
+        { STB0899_FECAUTO1              , 0x06 },
+        { STB0899_FECM                  , 0x01 },
+        { STB0899_VTH12                 , 0xb0 },
+        { STB0899_VTH23                 , 0x7a },
+        { STB0899_VTH34                 , 0x58 },
+        { STB0899_VTH56                 , 0x38 },
+        { STB0899_VTH67                 , 0x34 },
+        { STB0899_VTH78                 , 0x24 },
+        { STB0899_PRVIT                 , 0xff },
+        { STB0899_VITSYNC               , 0x19 },
+        { STB0899_RSULC                 , 0xb1 }, /* DVB = 0xb1, DSS = 0xa1 */
+        { STB0899_TSULC                 , 0x42 },
+        { STB0899_RSLLC                 , 0x41 },
+        { STB0899_TSLPL                 , 0x12 },
+        { STB0899_TSCFGH                , 0x0c },
+        { STB0899_TSCFGM                , 0x00 },
+        { STB0899_TSCFGL                , 0x00 },
+        { STB0899_TSOUT                 , 0x69 }, /* 0x0d for CAM */
+        { STB0899_RSSYNCDEL             , 0x00 },
+        { STB0899_TSINHDELH             , 0x02 },
+        { STB0899_TSINHDELM             , 0x00 },
+        { STB0899_TSINHDELL             , 0x00 },
+        { STB0899_TSLLSTKM              , 0x1b },
+        { STB0899_TSLLSTKL              , 0xb3 },
+        { STB0899_TSULSTKM              , 0x00 },
+        { STB0899_TSULSTKL              , 0x00 },
+        { STB0899_PCKLENUL              , 0xbc },
+        { STB0899_PCKLENLL              , 0xcc },
+        { STB0899_RSPCKLEN              , 0xbd },
+        { STB0899_TSSTATUS              , 0x90 },
+        { STB0899_ERRCTRL1              , 0xb6 },
+        { STB0899_ERRCTRL2              , 0x95 },
+        { STB0899_ERRCTRL3              , 0x8d },
+        { STB0899_DMONMSK1              , 0x27 },
+        { STB0899_DMONMSK0              , 0x03 },
+        { STB0899_DEMAPVIT              , 0x5c },
+        { STB0899_PLPARM                , 0x19 },
+        { STB0899_PDELCTRL              , 0x48 },
+        { STB0899_PDELCTRL2             , 0x00 },
+        { STB0899_BBHCTRL1              , 0x00 },
+        { STB0899_BBHCTRL2              , 0x00 },
+        { STB0899_HYSTTHRESH            , 0x77 },
+        { STB0899_MATCSTM               , 0x00 },
+        { STB0899_MATCSTL               , 0x00 },
+        { STB0899_UPLCSTM               , 0x00 },
+        { STB0899_UPLCSTL               , 0x00 },
+        { STB0899_DFLCSTM               , 0x00 },
+        { STB0899_DFLCSTL               , 0x00 },
+        { STB0899_SYNCCST               , 0x00 },
+        { STB0899_SYNCDCSTM             , 0x00 },
+        { STB0899_SYNCDCSTL             , 0x00 },
+        { STB0899_ISI_ENTRY             , 0x00 },
+        { STB0899_ISI_BIT_EN            , 0x00 },
+        { STB0899_MATSTRM               , 0xf0 },
+        { STB0899_MATSTRL               , 0x02 },
+        { STB0899_UPLSTRM               , 0x45 },
+        { STB0899_UPLSTRL               , 0x60 },
+        { STB0899_DFLSTRM               , 0xe3 },
+        { STB0899_DFLSTRL               , 0x00 },
+        { STB0899_SYNCSTR               , 0x47 },
+        { STB0899_SYNCDSTRM             , 0x05 },
+        { STB0899_SYNCDSTRL             , 0x18 },
+        { STB0899_CFGPDELSTATUS1        , 0x19 },
+        { STB0899_CFGPDELSTATUS2        , 0x2b },
+        { STB0899_BBFERRORM             , 0x00 },
+        { STB0899_BBFERRORL             , 0x01 },
+        { STB0899_UPKTERRORM            , 0x00 },
+        { STB0899_UPKTERRORL            , 0x00 },
+        { 0xffff                        , 0xff },
+};
+
+
+
+struct stb0899_config az6027_stb0899_config = {
+        .init_dev               = az6027_stb0899_s1_init_1,
+        .init_s2_demod          = stb0899_s2_init_2,
+        .init_s1_demod          = az6027_stb0899_s1_init_3,
+        .init_s2_fec            = stb0899_s2_init_4,
+        .init_tst               = stb0899_s1_init_5,
+
+        .demod_address          = 0xd0, /* 0x68, 0xd0 >> 1 */
+
+        .xtal_freq              = 27000000,
+        .inversion              = IQ_SWAP_ON, /* 1 */
+
+        .lo_clk                 = 76500000,
+        .hi_clk                 = 99000000,
+
+        .esno_ave               = STB0899_DVBS2_ESNO_AVE,
+        .esno_quant             = STB0899_DVBS2_ESNO_QUANT,
+        .avframes_coarse        = STB0899_DVBS2_AVFRAMES_COARSE,
+        .avframes_fine          = STB0899_DVBS2_AVFRAMES_FINE,
+        .miss_threshold         = STB0899_DVBS2_MISS_THRESHOLD,
+        .uwp_threshold_acq      = STB0899_DVBS2_UWP_THRESHOLD_ACQ,
+        .uwp_threshold_track    = STB0899_DVBS2_UWP_THRESHOLD_TRACK,
+        .uwp_threshold_sof      = STB0899_DVBS2_UWP_THRESHOLD_SOF,
+        .sof_search_timeout     = STB0899_DVBS2_SOF_SEARCH_TIMEOUT,
+
+        .btr_nco_bits           = STB0899_DVBS2_BTR_NCO_BITS,
+        .btr_gain_shift_offset  = STB0899_DVBS2_BTR_GAIN_SHIFT_OFFSET,
+        .crl_nco_bits           = STB0899_DVBS2_CRL_NCO_BITS,
+        .ldpc_max_iter          = STB0899_DVBS2_LDPC_MAX_ITER,
+
+        .tuner_get_frequency    = stb6100_get_frequency,
+        .tuner_set_frequency    = stb6100_set_frequency,
+        .tuner_set_bandwidth    = stb6100_set_bandwidth,
+        .tuner_get_bandwidth    = stb6100_get_bandwidth,
+        .tuner_set_rfsiggain    = NULL,
+};
+
+struct stb6100_config az6027_stb6100_config = {
+        .tuner_address  = 0xc0,
+        .refclock       = 27000000,
+};
+
+
+/* check for mutex FIXME */
+int az6027_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
+{
+        int ret = -1;
+        if (mutex_lock_interruptible(&d->usb_mutex))
+                return -EAGAIN;
+
+        ret = usb_control_msg(d->udev,
+                              usb_rcvctrlpipe(d->udev, 0),
+                              req,
+                              USB_TYPE_VENDOR | USB_DIR_IN,
+                              value,
+                              index,
+                              b,
+                              blen,
+                              2000);
+
+        if (ret < 0) {
+                warn("usb in operation failed. (%d)", ret);
+                ret = -EIO;
+        } else
+                ret = 0;
+
+        deb_xfer("in: req. %02x, val: %04x, ind: %04x, buffer: ", req, value, index);
+        debug_dump(b, blen, deb_xfer);
+
+        mutex_unlock(&d->usb_mutex);
+        return ret;
+}
+
+static int az6027_usb_out_op(struct dvb_usb_device *d,
+                             u8 req,
+                             u16 value,
+                             u16 index,
+                             u8 *b,
+                             int blen)
+{
+        int ret;
+
+        deb_xfer("out: req. %02x, val: %04x, ind: %04x, buffer: ", req, value, index);
+        debug_dump(b, blen, deb_xfer);
+
+        if (mutex_lock_interruptible(&d->usb_mutex))
+                return -EAGAIN;
+
+        ret = usb_control_msg(d->udev,
+                              usb_sndctrlpipe(d->udev, 0),
+                              req,
+                              USB_TYPE_VENDOR | USB_DIR_OUT,
+                              value,
+                              index,
+                              b,
+                              blen,
+                              2000);
+
+        if (ret != blen) {
+                warn("usb out operation failed. (%d)", ret);
+                mutex_unlock(&d->usb_mutex);
+                return -EIO;
+        } else{
+                mutex_unlock(&d->usb_mutex);
+                return 0;
+        }
+}
+
+static int az6027_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+
+        deb_info("%s %d", __func__, onoff);
+
+        req = 0xBC;
+        value = onoff;
+        index = 0;
+        blen = 0;
+
+        ret = az6027_usb_out_op(adap->dev, req, value, index, NULL, blen);
+        if (ret != 0)
+                warn("usb out operation failed. (%d)", ret);
+
+        return ret;
+}
+
+/* keys for the enclosed remote control */
+static struct rc_map_table rc_map_az6027_table[] = {
+        { 0x01, KEY_1 },
+        { 0x02, KEY_2 },
+};
+
+/* remote control stuff (does not work with my box) */
+static int az6027_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        return 0;
+}
+
+/*
+int az6027_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 v = onoff;
+        return az6027_usb_out_op(d,0xBC,v,3,NULL,1);
+}
+*/
+
+static int az6027_ci_read_attribute_mem(struct dvb_ca_en50221 *ca,
+                                        int slot,
+                                        int address)
+{
+        struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
+        struct az6027_device_state *state = (struct az6027_device_state *)d->priv;
+
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+        u8 *b;
+
+        if (slot != 0)
+                return -EINVAL;
+
+        b = kmalloc(12, GFP_KERNEL);
+        if (!b)
+                return -ENOMEM;
+
+        mutex_lock(&state->ca_mutex);
+
+        req = 0xC1;
+        value = address;
+        index = 0;
+        blen = 1;
+
+        ret = az6027_usb_in_op(d, req, value, index, b, blen);
+        if (ret < 0) {
+                warn("usb in operation failed. (%d)", ret);
+                ret = -EINVAL;
+        } else {
+                ret = b[0];
+        }
+
+        mutex_unlock(&state->ca_mutex);
+        kfree(b);
+        return ret;
+}
+
+static int az6027_ci_write_attribute_mem(struct dvb_ca_en50221 *ca,
+                                         int slot,
+                                         int address,
+                                         u8 value)
+{
+        struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
+        struct az6027_device_state *state = (struct az6027_device_state *)d->priv;
+
+        int ret;
+        u8 req;
+        u16 value1;
+        u16 index;
+        int blen;
+
+        deb_info("%s %d", __func__, slot);
+        if (slot != 0)
+                return -EINVAL;
+
+        mutex_lock(&state->ca_mutex);
+        req = 0xC2;
+        value1 = address;
+        index = value;
+        blen = 0;
+
+        ret = az6027_usb_out_op(d, req, value1, index, NULL, blen);
+        if (ret != 0)
+                warn("usb out operation failed. (%d)", ret);
+
+        mutex_unlock(&state->ca_mutex);
+        return ret;
+}
+
+static int az6027_ci_read_cam_control(struct dvb_ca_en50221 *ca,
+                                      int slot,
+                                      u8 address)
+{
+        struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
+        struct az6027_device_state *state = (struct az6027_device_state *)d->priv;
+
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+        u8 *b;
+
+        if (slot != 0)
+                return -EINVAL;
+
+        b = kmalloc(12, GFP_KERNEL);
+        if (!b)
+                return -ENOMEM;
+
+        mutex_lock(&state->ca_mutex);
+
+        req = 0xC3;
+        value = address;
+        index = 0;
+        blen = 2;
+
+        ret = az6027_usb_in_op(d, req, value, index, b, blen);
+        if (ret < 0) {
+                warn("usb in operation failed. (%d)", ret);
+                ret = -EINVAL;
+        } else {
+                if (b[0] == 0)
+                        warn("Read CI IO error");
+
+                ret = b[1];
+                deb_info("read cam data = %x from 0x%x", b[1], value);
+        }
+
+        mutex_unlock(&state->ca_mutex);
+        kfree(b);
+        return ret;
+}
+
+static int az6027_ci_write_cam_control(struct dvb_ca_en50221 *ca,
+                                       int slot,
+                                       u8 address,
+                                       u8 value)
+{
+        struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
+        struct az6027_device_state *state = (struct az6027_device_state *)d->priv;
+
+        int ret;
+        u8 req;
+        u16 value1;
+        u16 index;
+        int blen;
+
+        if (slot != 0)
+                return -EINVAL;
+
+        mutex_lock(&state->ca_mutex);
+        req = 0xC4;
+        value1 = address;
+        index = value;
+        blen = 0;
+
+        ret = az6027_usb_out_op(d, req, value1, index, NULL, blen);
+        if (ret != 0) {
+                warn("usb out operation failed. (%d)", ret);
+                goto failed;
+        }
+
+failed:
+        mutex_unlock(&state->ca_mutex);
+        return ret;
+}
+
+static int CI_CamReady(struct dvb_ca_en50221 *ca, int slot)
+{
+        struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
+
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+        u8 *b;
+
+        b = kmalloc(12, GFP_KERNEL);
+        if (!b)
+                return -ENOMEM;
+
+        req = 0xC8;
+        value = 0;
+        index = 0;
+        blen = 1;
+
+        ret = az6027_usb_in_op(d, req, value, index, b, blen);
+        if (ret < 0) {
+                warn("usb in operation failed. (%d)", ret);
+                ret = -EIO;
+        } else{
+                ret = b[0];
+        }
+        kfree(b);
+        return ret;
+}
+
+static int az6027_ci_slot_reset(struct dvb_ca_en50221 *ca, int slot)
+{
+        struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
+        struct az6027_device_state *state = (struct az6027_device_state *)d->priv;
+
+        int ret, i;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+
+        mutex_lock(&state->ca_mutex);
+
+        req = 0xC6;
+        value = 1;
+        index = 0;
+        blen = 0;
+
+        ret = az6027_usb_out_op(d, req, value, index, NULL, blen);
+        if (ret != 0) {
+                warn("usb out operation failed. (%d)", ret);
+                goto failed;
+        }
+
+        msleep(500);
+        req = 0xC6;
+        value = 0;
+        index = 0;
+        blen = 0;
+
+        ret = az6027_usb_out_op(d, req, value, index, NULL, blen);
+        if (ret != 0) {
+                warn("usb out operation failed. (%d)", ret);
+                goto failed;
+        }
+
+        for (i = 0; i < 15; i++) {
+                msleep(100);
+
+                if (CI_CamReady(ca, slot)) {
+                        deb_info("CAM Ready");
+                        break;
+                }
+        }
+        msleep(5000);
+
+failed:
+        mutex_unlock(&state->ca_mutex);
+        return ret;
+}
+
+static int az6027_ci_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
+{
+        return 0;
+}
+
+static int az6027_ci_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
+{
+        struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
+        struct az6027_device_state *state = (struct az6027_device_state *)d->priv;
+
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+
+        deb_info("%s", __func__);
+        mutex_lock(&state->ca_mutex);
+        req = 0xC7;
+        value = 1;
+        index = 0;
+        blen = 0;
+
+        ret = az6027_usb_out_op(d, req, value, index, NULL, blen);
+        if (ret != 0) {
+                warn("usb out operation failed. (%d)", ret);
+                goto failed;
+        }
+
+failed:
+        mutex_unlock(&state->ca_mutex);
+        return ret;
+}
+
+static int az6027_ci_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
+{
+        struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
+        struct az6027_device_state *state = (struct az6027_device_state *)d->priv;
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+        u8 *b;
+
+        b = kmalloc(12, GFP_KERNEL);
+        if (!b)
+                return -ENOMEM;
+        mutex_lock(&state->ca_mutex);
+
+        req = 0xC5;
+        value = 0;
+        index = 0;
+        blen = 1;
+
+        ret = az6027_usb_in_op(d, req, value, index, b, blen);
+        if (ret < 0) {
+                warn("usb in operation failed. (%d)", ret);
+                ret = -EIO;
+        } else
+                ret = 0;
+
+        if (!ret && b[0] == 1) {
+                ret = DVB_CA_EN50221_POLL_CAM_PRESENT |
+                      DVB_CA_EN50221_POLL_CAM_READY;
+        }
+
+        mutex_unlock(&state->ca_mutex);
+        kfree(b);
+        return ret;
+}
+
+
+static void az6027_ci_uninit(struct dvb_usb_device *d)
+{
+        struct az6027_device_state *state;
+
+        deb_info("%s", __func__);
+
+        if (NULL == d)
+                return;
+
+        state = (struct az6027_device_state *)d->priv;
+        if (NULL == state)
+                return;
+
+        if (NULL == state->ca.data)
+                return;
+
+        dvb_ca_en50221_release(&state->ca);
+
+        memset(&state->ca, 0, sizeof(state->ca));
+}
+
+
+static int az6027_ci_init(struct dvb_usb_adapter *a)
+{
+        struct dvb_usb_device *d = a->dev;
+        struct az6027_device_state *state = (struct az6027_device_state *)d->priv;
+        int ret;
+
+        deb_info("%s", __func__);
+
+        mutex_init(&state->ca_mutex);
+
+        state->ca.owner                 = THIS_MODULE;
+        state->ca.read_attribute_mem    = az6027_ci_read_attribute_mem;
+        state->ca.write_attribute_mem   = az6027_ci_write_attribute_mem;
+        state->ca.read_cam_control      = az6027_ci_read_cam_control;
+        state->ca.write_cam_control     = az6027_ci_write_cam_control;
+        state->ca.slot_reset            = az6027_ci_slot_reset;
+        state->ca.slot_shutdown         = az6027_ci_slot_shutdown;
+        state->ca.slot_ts_enable        = az6027_ci_slot_ts_enable;
+        state->ca.poll_slot_status      = az6027_ci_poll_slot_status;
+        state->ca.data                  = d;
+
+        ret = dvb_ca_en50221_init(&a->dvb_adap,
+                                  &state->ca,
+                                  0, /* flags */
+                                  1);/* n_slots */
+        if (ret != 0) {
+                err("Cannot initialize CI: Error %d.", ret);
+                memset(&state->ca, 0, sizeof(state->ca));
+                return ret;
+        }
+
+        deb_info("CI initialized.");
+
+        return 0;
+}
+
+/*
+static int az6027_read_mac_addr(struct dvb_usb_device *d, u8 mac[6])
+{
+        az6027_usb_in_op(d, 0xb7, 6, 0, &mac[0], 6);
+        return 0;
+}
+*/
+
+static int az6027_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
+{
+
+        u8 buf;
+        int ret;
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+
+        struct i2c_msg i2c_msg = {
+                .addr   = 0x99,
+                .flags  = 0,
+                .buf    = &buf,
+                .len    = 1
+        };
+
+        /*
+         * 2   --18v
+         * 1   --13v
+         * 0   --off
+         */
+        switch (voltage) {
+        case SEC_VOLTAGE_13:
+                buf = 1;
+                ret = i2c_transfer(&adap->dev->i2c_adap, &i2c_msg, 1);
+                break;
+
+        case SEC_VOLTAGE_18:
+                buf = 2;
+                ret = i2c_transfer(&adap->dev->i2c_adap, &i2c_msg, 1);
+                break;
+
+        case SEC_VOLTAGE_OFF:
+                buf = 0;
+                ret = i2c_transfer(&adap->dev->i2c_adap, &i2c_msg, 1);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+
+static int az6027_frontend_poweron(struct dvb_usb_adapter *adap)
+{
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+
+        req = 0xBC;
+        value = 1; /* power on */
+        index = 3;
+        blen = 0;
+
+        ret = az6027_usb_out_op(adap->dev, req, value, index, NULL, blen);
+        if (ret != 0)
+                return -EIO;
+
+        return 0;
+}
+static int az6027_frontend_reset(struct dvb_usb_adapter *adap)
+{
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+
+        /* reset demodulator */
+        req = 0xC0;
+        value = 1; /* high */
+        index = 3;
+        blen = 0;
+
+        ret = az6027_usb_out_op(adap->dev, req, value, index, NULL, blen);
+        if (ret != 0)
+                return -EIO;
+
+        req = 0xC0;
+        value = 0; /* low */
+        index = 3;
+        blen = 0;
+        msleep_interruptible(200);
+
+        ret = az6027_usb_out_op(adap->dev, req, value, index, NULL, blen);
+        if (ret != 0)
+                return -EIO;
+
+        msleep_interruptible(200);
+
+        req = 0xC0;
+        value = 1; /*high */
+        index = 3;
+        blen = 0;
+
+        ret = az6027_usb_out_op(adap->dev, req, value, index, NULL, blen);
+        if (ret != 0)
+                return -EIO;
+
+        msleep_interruptible(200);
+        return 0;
+}
+
+static int az6027_frontend_tsbypass(struct dvb_usb_adapter *adap, int onoff)
+{
+        int ret;
+        u8 req;
+        u16 value;
+        u16 index;
+        int blen;
+
+        /* TS passthrough */
+        req = 0xC7;
+        value = onoff;
+        index = 0;
+        blen = 0;
+
+        ret = az6027_usb_out_op(adap->dev, req, value, index, NULL, blen);
+        if (ret != 0)
+                return -EIO;
+
+        return 0;
+}
+
+static int az6027_frontend_attach(struct dvb_usb_adapter *adap)
+{
+
+        az6027_frontend_poweron(adap);
+        az6027_frontend_reset(adap);
+
+        deb_info("adap = %p, dev = %p\n", adap, adap->dev);
+        adap->fe = stb0899_attach(&az6027_stb0899_config, &adap->dev->i2c_adap);
+
+        if (adap->fe) {
+                deb_info("found STB0899 DVB-S/DVB-S2 frontend @0x%02x", az6027_stb0899_config.demod_address);
+                if (stb6100_attach(adap->fe, &az6027_stb6100_config, &adap->dev->i2c_adap)) {
+                        deb_info("found STB6100 DVB-S/DVB-S2 frontend @0x%02x", az6027_stb6100_config.tuner_address);
+                        adap->fe->ops.set_voltage = az6027_set_voltage;
+                        az6027_ci_init(adap);
+                } else {
+                        adap->fe = NULL;
+                }
+        } else
+                warn("no front-end attached\n");
+
+        az6027_frontend_tsbypass(adap, 0);
+
+        return 0;
+}
+
+static struct dvb_usb_device_properties az6027_properties;
+
+static void az6027_usb_disconnect(struct usb_interface *intf)
+{
+        struct dvb_usb_device *d = usb_get_intfdata(intf);
+        az6027_ci_uninit(d);
+        dvb_usb_device_exit(intf);
+}
+
+
+static int az6027_usb_probe(struct usb_interface *intf,
+                            const struct usb_device_id *id)
+{
+        return dvb_usb_device_init(intf,
+                                   &az6027_properties,
+                                   THIS_MODULE,
+                                   NULL,
+                                   adapter_nr);
+}
+
+/* I2C */
+static int az6027_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i = 0, j = 0, len = 0;
+        int ret;
+        u16 index;
+        u16 value;
+        int length;
+        u8 req;
+        u8 *data;
+
+        data = kmalloc(256, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0) {
+                kfree(data);
+                return -EAGAIN;
+        }
+
+        if (num > 2)
+                warn("more than 2 i2c messages at a time is not handled yet. TODO.");
+
+        for (i = 0; i < num; i++) {
+
+                if (msg[i].addr == 0x99) {
+                        req = 0xBE;
+                        index = 0;
+                        value = msg[i].buf[0] & 0x00ff;
+                        length = 1;
+                        az6027_usb_out_op(d, req, value, index, data, length);
+                }
+
+                if (msg[i].addr == 0xd0) {
+                        /* write/read request */
+                        if (i + 1 < num && (msg[i + 1].flags & I2C_M_RD)) {
+                                req = 0xB9;
+                                index = (((msg[i].buf[0] << 8) & 0xff00) | (msg[i].buf[1] & 0x00ff));
+                                value = msg[i].addr + (msg[i].len << 8);
+                                length = msg[i + 1].len + 6;
+                                ret = az6027_usb_in_op(d, req, value, index, data, length);
+                                len = msg[i + 1].len;
+                                for (j = 0; j < len; j++)
+                                        msg[i + 1].buf[j] = data[j + 5];
+
+                                i++;
+                        } else {
+
+                                /* demod 16bit addr */
+                                req = 0xBD;
+                                index = (((msg[i].buf[0] << 8) & 0xff00) | (msg[i].buf[1] & 0x00ff));
+                                value = msg[i].addr + (2 << 8);
+                                length = msg[i].len - 2;
+                                len = msg[i].len - 2;
+                                for (j = 0; j < len; j++)
+                                        data[j] = msg[i].buf[j + 2];
+                                az6027_usb_out_op(d, req, value, index, data, length);
+                        }
+                }
+
+                if (msg[i].addr == 0xc0) {
+                        if (msg[i].flags & I2C_M_RD) {
+
+                                req = 0xB9;
+                                index = 0x0;
+                                value = msg[i].addr;
+                                length = msg[i].len + 6;
+                                ret = az6027_usb_in_op(d, req, value, index, data, length);
+                                len = msg[i].len;
+                                for (j = 0; j < len; j++)
+                                        msg[i].buf[j] = data[j + 5];
+
+                        } else {
+
+                                req = 0xBD;
+                                index = msg[i].buf[0] & 0x00FF;
+                                value = msg[i].addr + (1 << 8);
+                                length = msg[i].len - 1;
+                                len = msg[i].len - 1;
+
+                                for (j = 0; j < len; j++)
+                                        data[j] = msg[i].buf[j + 1];
+
+                                az6027_usb_out_op(d, req, value, index, data, length);
+                        }
+                }
+        }
+        mutex_unlock(&d->i2c_mutex);
+        kfree(data);
+
+        return i;
+}
+
+
+static u32 az6027_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm az6027_i2c_algo = {
+        .master_xfer   = az6027_i2c_xfer,
+        .functionality = az6027_i2c_func,
+};
+
+int az6027_identify_state(struct usb_device *udev,
+                          struct dvb_usb_device_properties *props,
+                          struct dvb_usb_device_description **desc,
+                          int *cold)
+{
+        u8 *b;
+        s16 ret;
+
+        b = kmalloc(16, GFP_KERNEL);
+        if (!b)
+                return -ENOMEM;
+
+        ret = usb_control_msg(udev,
+                                  usb_rcvctrlpipe(udev, 0),
+                                  0xb7,
+                                  USB_TYPE_VENDOR | USB_DIR_IN,
+                                  6,
+                                  0,
+                                  b,
+                                  6,
+                                  USB_CTRL_GET_TIMEOUT);
+
+        *cold = ret <= 0;
+        kfree(b);
+        deb_info("cold: %d\n", *cold);
+        return 0;
+}
+
+
+static struct usb_device_id az6027_usb_table[] = {
+        { USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_AZUREWAVE_AZ6027) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_DVBS2CI_V1) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_DVBS2CI_V2) },
+        { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_USB2_HDCI_V1) },
+        { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_USB2_HDCI_V2) },
+        { USB_DEVICE(USB_VID_ELGATO, USB_PID_ELGATO_EYETV_SAT) },
+        { },
+};
+
+MODULE_DEVICE_TABLE(usb, az6027_usb_table);
+
+static struct dvb_usb_device_properties az6027_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware            = "dvb-usb-az6027-03.fw",
+        .no_reconnect        = 1,
+
+        .size_of_priv     = sizeof(struct az6027_device_state),
+        .identify_state         = az6027_identify_state,
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = az6027_streaming_ctrl,
+                        .frontend_attach  = az6027_frontend_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 10,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+/*
+        .power_ctrl       = az6027_power_ctrl,
+        .read_mac_address = az6027_read_mac_addr,
+ */
+        .rc.legacy = {
+                .rc_map_table     = rc_map_az6027_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_az6027_table),
+                .rc_interval      = 400,
+                .rc_query         = az6027_rc_query,
+        },
+
+        .i2c_algo         = &az6027_i2c_algo,
+
+        .num_device_descs = 6,
+        .devices = {
+                {
+                        .name = "AZUREWAVE DVB-S/S2 USB2.0 (AZ6027)",
+                        .cold_ids = { &az6027_usb_table[0], NULL },
+                        .warm_ids = { NULL },
+                }, {
+                        .name = "TERRATEC S7",
+                        .cold_ids = { &az6027_usb_table[1], NULL },
+                        .warm_ids = { NULL },
+                }, {
+                        .name = "TERRATEC S7 MKII",
+                        .cold_ids = { &az6027_usb_table[2], NULL },
+                        .warm_ids = { NULL },
+                }, {
+                        .name = "Technisat SkyStar USB 2 HD CI",
+                        .cold_ids = { &az6027_usb_table[3], NULL },
+                        .warm_ids = { NULL },
+                }, {
+                        .name = "Technisat SkyStar USB 2 HD CI",
+                        .cold_ids = { &az6027_usb_table[4], NULL },
+                        .warm_ids = { NULL },
+                }, {
+                        .name = "Elgato EyeTV Sat",
+                        .cold_ids = { &az6027_usb_table[5], NULL },
+                        .warm_ids = { NULL },
+                },
+                { NULL },
+        }
+};
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver az6027_usb_driver = {
+        .name           = "dvb_usb_az6027",
+        .probe          = az6027_usb_probe,
+        .disconnect     = az6027_usb_disconnect,
+        .id_table       = az6027_usb_table,
+};
+
+/* module stuff */
+static int __init az6027_usb_module_init(void)
+{
+        int result;
+
+        result = usb_register(&az6027_usb_driver);
+        if (result) {
+                err("usb_register failed. (%d)", result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit az6027_usb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&az6027_usb_driver);
+}
+
+module_init(az6027_usb_module_init);
+module_exit(az6027_usb_module_exit);
+
+MODULE_AUTHOR("Adams Xu <Adams.xu@azwave.com.cn>");
+MODULE_DESCRIPTION("Driver for AZUREWAVE DVB-S/S2 USB2.0 (AZ6027)");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/az6027.h b/drivers/media/dvb/dvb-usb/az6027.h
new file mode 100644
index 00000000000..f3afe17f3f3
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/az6027.h
@@ -0,0 +1,14 @@
+#ifndef _DVB_USB_VP6027_H_
+#define _DVB_USB_VP6027_H_
+
+#define DVB_USB_LOG_PREFIX "az6027"
+#include "dvb-usb.h"
+
+
+extern int dvb_usb_az6027_debug;
+#define deb_info(args...) dprintk(dvb_usb_az6027_debug, 0x01, args)
+#define deb_xfer(args...) dprintk(dvb_usb_az6027_debug, 0x02, args)
+#define deb_rc(args...)   dprintk(dvb_usb_az6027_debug, 0x04, args)
+#define deb_fe(args...)   dprintk(dvb_usb_az6027_debug, 0x08, args)
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/ce6230.c b/drivers/media/dvb/dvb-usb/ce6230.c
new file mode 100644
index 00000000000..6d1a3041540
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/ce6230.c
@@ -0,0 +1,341 @@
+/*
+ * DVB USB Linux driver for Intel CE6230 DVB-T USB2.0 receiver
+ *
+ * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
+ *
+ *    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 "ce6230.h"
+#include "zl10353.h"
+#include "mxl5005s.h"
+
+/* debug */
+static int dvb_usb_ce6230_debug;
+module_param_named(debug, dvb_usb_ce6230_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static struct zl10353_config ce6230_zl10353_config;
+
+static int ce6230_rw_udev(struct usb_device *udev, struct req_t *req)
+{
+        int ret;
+        unsigned int pipe;
+        u8 request;
+        u8 requesttype;
+        u16 value;
+        u16 index;
+        u8 *buf;
+
+        request = req->cmd;
+        value = req->value;
+        index = req->index;
+
+        switch (req->cmd) {
+        case I2C_READ:
+        case DEMOD_READ:
+        case REG_READ:
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
+                break;
+        case I2C_WRITE:
+        case DEMOD_WRITE:
+        case REG_WRITE:
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
+                break;
+        default:
+                err("unknown command:%02x", req->cmd);
+                ret = -EPERM;
+                goto error;
+        }
+
+        buf = kmalloc(req->data_len, GFP_KERNEL);
+        if (!buf) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        if (requesttype == (USB_TYPE_VENDOR | USB_DIR_OUT)) {
+                /* write */
+                memcpy(buf, req->data, req->data_len);
+                pipe = usb_sndctrlpipe(udev, 0);
+        } else {
+                /* read */
+                pipe = usb_rcvctrlpipe(udev, 0);
+        }
+
+        msleep(1); /* avoid I2C errors */
+
+        ret = usb_control_msg(udev, pipe, request, requesttype, value, index,
+                                buf, req->data_len, CE6230_USB_TIMEOUT);
+
+        ce6230_debug_dump(request, requesttype, value, index, buf,
+                req->data_len, deb_xfer);
+
+        if (ret < 0)
+                deb_info("%s: usb_control_msg failed:%d\n", __func__, ret);
+        else
+                ret = 0;
+
+        /* read request, copy returned data to return buf */
+        if (!ret && requesttype == (USB_TYPE_VENDOR | USB_DIR_IN))
+                memcpy(req->data, buf, req->data_len);
+
+        kfree(buf);
+error:
+        return ret;
+}
+
+static int ce6230_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
+{
+        return ce6230_rw_udev(d->udev, req);
+}
+
+/* I2C */
+static int ce6230_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                           int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i = 0;
+        struct req_t req;
+        int ret = 0;
+        memset(&req, 0, sizeof(req));
+
+        if (num > 2)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        while (i < num) {
+                if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
+                        if (msg[i].addr ==
+                                ce6230_zl10353_config.demod_address) {
+                                req.cmd = DEMOD_READ;
+                                req.value = msg[i].addr >> 1;
+                                req.index = msg[i].buf[0];
+                                req.data_len = msg[i+1].len;
+                                req.data = &msg[i+1].buf[0];
+                                ret = ce6230_ctrl_msg(d, &req);
+                        } else {
+                                err("i2c read not implemented");
+                                ret = -EPERM;
+                        }
+                        i += 2;
+                } else {
+                        if (msg[i].addr ==
+                                ce6230_zl10353_config.demod_address) {
+                                req.cmd = DEMOD_WRITE;
+                                req.value = msg[i].addr >> 1;
+                                req.index = msg[i].buf[0];
+                                req.data_len = msg[i].len-1;
+                                req.data = &msg[i].buf[1];
+                                ret = ce6230_ctrl_msg(d, &req);
+                        } else {
+                                req.cmd = I2C_WRITE;
+                                req.value = 0x2000 + (msg[i].addr >> 1);
+                                req.index = 0x0000;
+                                req.data_len = msg[i].len;
+                                req.data = &msg[i].buf[0];
+                                ret = ce6230_ctrl_msg(d, &req);
+                        }
+                        i += 1;
+                }
+                if (ret)
+                        break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return ret ? ret : i;
+}
+
+static u32 ce6230_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm ce6230_i2c_algo = {
+        .master_xfer   = ce6230_i2c_xfer,
+        .functionality = ce6230_i2c_func,
+};
+
+/* Callbacks for DVB USB */
+static struct zl10353_config ce6230_zl10353_config = {
+        .demod_address = 0x1e,
+        .adc_clock = 450000,
+        .if2 = 45700,
+        .no_tuner = 1,
+        .parallel_ts = 1,
+        .clock_ctl_1 = 0x34,
+        .pll_0 = 0x0e,
+};
+
+static int ce6230_zl10353_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        deb_info("%s:\n", __func__);
+        adap->fe = dvb_attach(zl10353_attach, &ce6230_zl10353_config,
+                &adap->dev->i2c_adap);
+        if (adap->fe == NULL)
+                return -ENODEV;
+        return 0;
+}
+
+static struct mxl5005s_config ce6230_mxl5003s_config = {
+        .i2c_address     = 0xc6,
+        .if_freq         = IF_FREQ_4570000HZ,
+        .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
+        .agc_mode        = MXL_SINGLE_AGC,
+        .tracking_filter = MXL_TF_DEFAULT,
+        .rssi_enable     = MXL_RSSI_ENABLE,
+        .cap_select      = MXL_CAP_SEL_ENABLE,
+        .div_out         = MXL_DIV_OUT_4,
+        .clock_out       = MXL_CLOCK_OUT_DISABLE,
+        .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
+        .top             = MXL5005S_TOP_25P2,
+        .mod_mode        = MXL_DIGITAL_MODE,
+        .if_mode         = MXL_ZERO_IF,
+        .AgcMasterByte   = 0x00,
+};
+
+static int ce6230_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        int ret;
+        deb_info("%s:\n", __func__);
+        ret = dvb_attach(mxl5005s_attach, adap->fe, &adap->dev->i2c_adap,
+                        &ce6230_mxl5003s_config) == NULL ? -ENODEV : 0;
+        return ret;
+}
+
+static int ce6230_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        int ret;
+        deb_info("%s: onoff:%d\n", __func__, onoff);
+
+        /* InterfaceNumber 1 / AlternateSetting 0     idle
+           InterfaceNumber 1 / AlternateSetting 1     streaming */
+        ret = usb_set_interface(d->udev, 1, onoff);
+        if (ret)
+                err("usb_set_interface failed with error:%d", ret);
+
+        return ret;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties ce6230_properties;
+
+static int ce6230_probe(struct usb_interface *intf,
+                        const struct usb_device_id *id)
+{
+        int ret = 0;
+        struct dvb_usb_device *d = NULL;
+
+        deb_info("%s: interface:%d\n", __func__,
+                intf->cur_altsetting->desc.bInterfaceNumber);
+
+        if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
+                ret = dvb_usb_device_init(intf, &ce6230_properties, THIS_MODULE,
+                        &d, adapter_nr);
+                if (ret)
+                        err("init failed with error:%d\n", ret);
+        }
+
+        return ret;
+}
+
+static struct usb_device_id ce6230_table[] = {
+        { USB_DEVICE(USB_VID_INTEL, USB_PID_INTEL_CE9500) },
+        { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A310) },
+        { } /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, ce6230_table);
+
+static struct dvb_usb_device_properties ce6230_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .no_reconnect = 1,
+
+        .size_of_priv = 0,
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .frontend_attach  = ce6230_zl10353_frontend_attach,
+                        .tuner_attach     = ce6230_mxl5003s_tuner_attach,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 6,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = (16*512),
+                                        }
+                                }
+                        },
+                }
+        },
+
+        .power_ctrl = ce6230_power_ctrl,
+
+        .i2c_algo = &ce6230_i2c_algo,
+
+        .num_device_descs = 2,
+        .devices = {
+                {
+                        .name = "Intel CE9500 reference design",
+                        .cold_ids = {NULL},
+                        .warm_ids = {&ce6230_table[0], NULL},
+                },
+                {
+                        .name = "AVerMedia A310 USB 2.0 DVB-T tuner",
+                        .cold_ids = {NULL},
+                        .warm_ids = {&ce6230_table[1], NULL},
+                },
+        }
+};
+
+static struct usb_driver ce6230_driver = {
+        .name       = "dvb_usb_ce6230",
+        .probe      = ce6230_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table   = ce6230_table,
+};
+
+/* module stuff */
+static int __init ce6230_module_init(void)
+{
+        int ret;
+        deb_info("%s:\n", __func__);
+        ret = usb_register(&ce6230_driver);
+        if (ret)
+                err("usb_register failed with error:%d", ret);
+
+        return ret;
+}
+
+static void __exit ce6230_module_exit(void)
+{
+        deb_info("%s:\n", __func__);
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&ce6230_driver);
+}
+
+module_init(ce6230_module_init);
+module_exit(ce6230_module_exit);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("Driver for Intel CE6230 DVB-T USB2.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/ce6230.h b/drivers/media/dvb/dvb-usb/ce6230.h
new file mode 100644
index 00000000000..97c42482ccb
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/ce6230.h
@@ -0,0 +1,69 @@
+/*
+ * DVB USB Linux driver for Intel CE6230 DVB-T USB2.0 receiver
+ *
+ * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
+ *
+ *    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_USB_CE6230_H_
+#define _DVB_USB_CE6230_H_
+
+#define DVB_USB_LOG_PREFIX "ce6230"
+#include "dvb-usb.h"
+
+#define deb_info(args...) dprintk(dvb_usb_ce6230_debug, 0x01, args)
+#define deb_rc(args...)   dprintk(dvb_usb_ce6230_debug, 0x02, args)
+#define deb_xfer(args...) dprintk(dvb_usb_ce6230_debug, 0x04, args)
+#define deb_reg(args...)  dprintk(dvb_usb_ce6230_debug, 0x08, args)
+#define deb_i2c(args...)  dprintk(dvb_usb_ce6230_debug, 0x10, args)
+#define deb_fw(args...)   dprintk(dvb_usb_ce6230_debug, 0x20, args)
+
+#define ce6230_debug_dump(r, t, v, i, b, l, func) { \
+        int loop_; \
+        func("%02x %02x %02x %02x %02x %02x %02x %02x", \
+                t, r, v & 0xff, v >> 8, i & 0xff, i >> 8, l & 0xff, l >> 8); \
+        if (t == (USB_TYPE_VENDOR | USB_DIR_OUT)) \
+                func(" >>> "); \
+        else \
+                func(" <<< "); \
+        for (loop_ = 0; loop_ < l; loop_++) \
+                func("%02x ", b[loop_]); \
+        func("\n");\
+}
+
+#define CE6230_USB_TIMEOUT 1000
+
+struct req_t {
+        u8  cmd;       /* [1] */
+        u16 value;     /* [2|3] */
+        u16 index;     /* [4|5] */
+        u16 data_len;  /* [6|7] */
+        u8  *data;
+};
+
+enum ce6230_cmd {
+        CONFIG_READ          = 0xd0, /* rd 0 (unclear) */
+        UNKNOWN_WRITE        = 0xc7, /* wr 7 (unclear) */
+        I2C_READ             = 0xd9, /* rd 9 (unclear) */
+        I2C_WRITE            = 0xca, /* wr a */
+        DEMOD_READ           = 0xdb, /* rd b */
+        DEMOD_WRITE          = 0xcc, /* wr c */
+        REG_READ             = 0xde, /* rd e */
+        REG_WRITE            = 0xcf, /* wr f */
+};
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/cinergyT2-core.c b/drivers/media/dvb/dvb-usb/cinergyT2-core.c
new file mode 100644
index 00000000000..16f2ce2bc15
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/cinergyT2-core.c
@@ -0,0 +1,269 @@
+/*
+ * TerraTec Cinergy T2/qanu USB2 DVB-T adapter.
+ *
+ * Copyright (C) 2007 Tomi Orava (tomimo@ncircle.nullnet.fi)
+ *
+ * Based on the dvb-usb-framework code and the
+ * original Terratec Cinergy T2 driver by:
+ *
+ * Copyright (C) 2004 Daniel Mack <daniel@qanu.de> and
+ *                  Holger Waechtler <holger@qanu.de>
+ *
+ *  Protocol Spec published on http://qanu.de/specs/terratec_cinergyT2.pdf
+ *
+ * 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 "cinergyT2.h"
+
+
+/* debug */
+int dvb_usb_cinergyt2_debug;
+
+module_param_named(debug, dvb_usb_cinergyt2_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info, xfer=2, rc=4 "
+                "(or-able)).");
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+struct cinergyt2_state {
+        u8 rc_counter;
+};
+
+/* We are missing a release hook with usb_device data */
+static struct dvb_usb_device *cinergyt2_usb_device;
+
+static struct dvb_usb_device_properties cinergyt2_properties;
+
+static int cinergyt2_streaming_ctrl(struct dvb_usb_adapter *adap, int enable)
+{
+        char buf[] = { CINERGYT2_EP1_CONTROL_STREAM_TRANSFER, enable ? 1 : 0 };
+        char result[64];
+        return dvb_usb_generic_rw(adap->dev, buf, sizeof(buf), result,
+                                sizeof(result), 0);
+}
+
+static int cinergyt2_power_ctrl(struct dvb_usb_device *d, int enable)
+{
+        char buf[] = { CINERGYT2_EP1_SLEEP_MODE, enable ? 0 : 1 };
+        char state[3];
+        return dvb_usb_generic_rw(d, buf, sizeof(buf), state, sizeof(state), 0);
+}
+
+static int cinergyt2_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        char query[] = { CINERGYT2_EP1_GET_FIRMWARE_VERSION };
+        char state[3];
+        int ret;
+
+        adap->fe = cinergyt2_fe_attach(adap->dev);
+
+        ret = dvb_usb_generic_rw(adap->dev, query, sizeof(query), state,
+                                sizeof(state), 0);
+        if (ret < 0) {
+                deb_rc("cinergyt2_power_ctrl() Failed to retrieve sleep "
+                        "state info\n");
+        }
+
+        /* Copy this pointer as we are gonna need it in the release phase */
+        cinergyt2_usb_device = adap->dev;
+
+        return 0;
+}
+
+static struct rc_map_table rc_map_cinergyt2_table[] = {
+        { 0x0401, KEY_POWER },
+        { 0x0402, KEY_1 },
+        { 0x0403, KEY_2 },
+        { 0x0404, KEY_3 },
+        { 0x0405, KEY_4 },
+        { 0x0406, KEY_5 },
+        { 0x0407, KEY_6 },
+        { 0x0408, KEY_7 },
+        { 0x0409, KEY_8 },
+        { 0x040a, KEY_9 },
+        { 0x040c, KEY_0 },
+        { 0x040b, KEY_VIDEO },
+        { 0x040d, KEY_REFRESH },
+        { 0x040e, KEY_SELECT },
+        { 0x040f, KEY_EPG },
+        { 0x0410, KEY_UP },
+        { 0x0414, KEY_DOWN },
+        { 0x0411, KEY_LEFT },
+        { 0x0413, KEY_RIGHT },
+        { 0x0412, KEY_OK },
+        { 0x0415, KEY_TEXT },
+        { 0x0416, KEY_INFO },
+        { 0x0417, KEY_RED },
+        { 0x0418, KEY_GREEN },
+        { 0x0419, KEY_YELLOW },
+        { 0x041a, KEY_BLUE },
+        { 0x041c, KEY_VOLUMEUP },
+        { 0x041e, KEY_VOLUMEDOWN },
+        { 0x041d, KEY_MUTE },
+        { 0x041b, KEY_CHANNELUP },
+        { 0x041f, KEY_CHANNELDOWN },
+        { 0x0440, KEY_PAUSE },
+        { 0x044c, KEY_PLAY },
+        { 0x0458, KEY_RECORD },
+        { 0x0454, KEY_PREVIOUS },
+        { 0x0448, KEY_STOP },
+        { 0x045c, KEY_NEXT }
+};
+
+/* Number of keypresses to ignore before detect repeating */
+#define RC_REPEAT_DELAY 3
+
+static int repeatable_keys[] = {
+        KEY_UP,
+        KEY_DOWN,
+        KEY_LEFT,
+        KEY_RIGHT,
+        KEY_VOLUMEUP,
+        KEY_VOLUMEDOWN,
+        KEY_CHANNELUP,
+        KEY_CHANNELDOWN
+};
+
+static int cinergyt2_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        struct cinergyt2_state *st = d->priv;
+        u8 key[5] = {0, 0, 0, 0, 0}, cmd = CINERGYT2_EP1_GET_RC_EVENTS;
+        int i;
+
+        *state = REMOTE_NO_KEY_PRESSED;
+
+        dvb_usb_generic_rw(d, &cmd, 1, key, sizeof(key), 0);
+        if (key[4] == 0xff) {
+                /* key repeat */
+                st->rc_counter++;
+                if (st->rc_counter > RC_REPEAT_DELAY) {
+                        for (i = 0; i < ARRAY_SIZE(repeatable_keys); i++) {
+                                if (d->last_event == repeatable_keys[i]) {
+                                        *state = REMOTE_KEY_REPEAT;
+                                        *event = d->last_event;
+                                        deb_rc("repeat key, event %x\n",
+                                                   *event);
+                                        return 0;
+                                }
+                        }
+                        deb_rc("repeated key (non repeatable)\n");
+                }
+                return 0;
+        }
+
+        /* hack to pass checksum on the custom field */
+        key[2] = ~key[1];
+        dvb_usb_nec_rc_key_to_event(d, key, event, state);
+        if (key[0] != 0) {
+                if (*event != d->last_event)
+                        st->rc_counter = 0;
+
+                deb_rc("key: %x %x %x %x %x\n",
+                       key[0], key[1], key[2], key[3], key[4]);
+        }
+        return 0;
+}
+
+static int cinergyt2_usb_probe(struct usb_interface *intf,
+                                const struct usb_device_id *id)
+{
+        return dvb_usb_device_init(intf, &cinergyt2_properties,
+                                        THIS_MODULE, NULL, adapter_nr);
+}
+
+
+static struct usb_device_id cinergyt2_usb_table[] = {
+        { USB_DEVICE(USB_VID_TERRATEC, 0x0038) },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(usb, cinergyt2_usb_table);
+
+static struct dvb_usb_device_properties cinergyt2_properties = {
+        .size_of_priv = sizeof(struct cinergyt2_state),
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cinergyt2_streaming_ctrl,
+                        .frontend_attach  = cinergyt2_frontend_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 512,
+                                        }
+                                }
+                        },
+                }
+        },
+
+        .power_ctrl       = cinergyt2_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval      = 50,
+                .rc_map_table     = rc_map_cinergyt2_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_cinergyt2_table),
+                .rc_query         = cinergyt2_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 1,
+
+        .num_device_descs = 1,
+        .devices = {
+                { .name = "TerraTec/qanu USB2.0 Highspeed DVB-T Receiver",
+                  .cold_ids = {NULL},
+                  .warm_ids = { &cinergyt2_usb_table[0], NULL },
+                },
+                { NULL },
+        }
+};
+
+
+static struct usb_driver cinergyt2_driver = {
+        .name           = "cinergyT2",
+        .probe          = cinergyt2_usb_probe,
+        .disconnect     = dvb_usb_device_exit,
+        .id_table       = cinergyt2_usb_table
+};
+
+static int __init cinergyt2_usb_init(void)
+{
+        int err;
+
+        err = usb_register(&cinergyt2_driver);
+        if (err) {
+                err("usb_register() failed! (err %i)\n", err);
+                return err;
+        }
+        return 0;
+}
+
+static void __exit cinergyt2_usb_exit(void)
+{
+        usb_deregister(&cinergyt2_driver);
+}
+
+module_init(cinergyt2_usb_init);
+module_exit(cinergyt2_usb_exit);
+
+MODULE_DESCRIPTION("Terratec Cinergy T2 DVB-T driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Tomi Orava");
diff --git a/drivers/media/dvb/dvb-usb/cinergyT2-fe.c b/drivers/media/dvb/dvb-usb/cinergyT2-fe.c
new file mode 100644
index 00000000000..9cd51ac1207
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/cinergyT2-fe.c
@@ -0,0 +1,352 @@
+/*
+ * TerraTec Cinergy T2/qanu USB2 DVB-T adapter.
+ *
+ * Copyright (C) 2007 Tomi Orava (tomimo@ncircle.nullnet.fi)
+ *
+ * Based on the dvb-usb-framework code and the
+ * original Terratec Cinergy T2 driver by:
+ *
+ * Copyright (C) 2004 Daniel Mack <daniel@qanu.de> and
+ *                  Holger Waechtler <holger@qanu.de>
+ *
+ *  Protocol Spec published on http://qanu.de/specs/terratec_cinergyT2.pdf
+ *
+ * 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 "cinergyT2.h"
+
+
+/**
+ *  convert linux-dvb frontend parameter set into TPS.
+ *  See ETSI ETS-300744, section 4.6.2, table 9 for details.
+ *
+ *  This function is probably reusable and may better get placed in a support
+ *  library.
+ *
+ *  We replace errornous fields by default TPS fields (the ones with value 0).
+ */
+
+static uint16_t compute_tps(struct dvb_frontend_parameters *p)
+{
+        struct dvb_ofdm_parameters *op = &p->u.ofdm;
+        uint16_t tps = 0;
+
+        switch (op->code_rate_HP) {
+        case FEC_2_3:
+                tps |= (1 << 7);
+                break;
+        case FEC_3_4:
+                tps |= (2 << 7);
+                break;
+        case FEC_5_6:
+                tps |= (3 << 7);
+                break;
+        case FEC_7_8:
+                tps |= (4 << 7);
+                break;
+        case FEC_1_2:
+        case FEC_AUTO:
+        default:
+                /* tps |= (0 << 7) */;
+        }
+
+        switch (op->code_rate_LP) {
+        case FEC_2_3:
+                tps |= (1 << 4);
+                break;
+        case FEC_3_4:
+                tps |= (2 << 4);
+                break;
+        case FEC_5_6:
+                tps |= (3 << 4);
+                break;
+        case FEC_7_8:
+                tps |= (4 << 4);
+                break;
+        case FEC_1_2:
+        case FEC_AUTO:
+        default:
+                /* tps |= (0 << 4) */;
+        }
+
+        switch (op->constellation) {
+        case QAM_16:
+                tps |= (1 << 13);
+                break;
+        case QAM_64:
+                tps |= (2 << 13);
+                break;
+        case QPSK:
+        default:
+                /* tps |= (0 << 13) */;
+        }
+
+        switch (op->transmission_mode) {
+        case TRANSMISSION_MODE_8K:
+                tps |= (1 << 0);
+                break;
+        case TRANSMISSION_MODE_2K:
+        default:
+                /* tps |= (0 << 0) */;
+        }
+
+        switch (op->guard_interval) {
+        case GUARD_INTERVAL_1_16:
+                tps |= (1 << 2);
+                break;
+        case GUARD_INTERVAL_1_8:
+                tps |= (2 << 2);
+                break;
+        case GUARD_INTERVAL_1_4:
+                tps |= (3 << 2);
+                break;
+        case GUARD_INTERVAL_1_32:
+        default:
+                /* tps |= (0 << 2) */;
+        }
+
+        switch (op->hierarchy_information) {
+        case HIERARCHY_1:
+                tps |= (1 << 10);
+                break;
+        case HIERARCHY_2:
+                tps |= (2 << 10);
+                break;
+        case HIERARCHY_4:
+                tps |= (3 << 10);
+                break;
+        case HIERARCHY_NONE:
+        default:
+                /* tps |= (0 << 10) */;
+        }
+
+        return tps;
+}
+
+struct cinergyt2_fe_state {
+        struct dvb_frontend fe;
+        struct dvb_usb_device *d;
+};
+
+static int cinergyt2_fe_read_status(struct dvb_frontend *fe,
+                                        fe_status_t *status)
+{
+        struct cinergyt2_fe_state *state = fe->demodulator_priv;
+        struct dvbt_get_status_msg result;
+        u8 cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
+        int ret;
+
+        ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (u8 *)&result,
+                        sizeof(result), 0);
+        if (ret < 0)
+                return ret;
+
+        *status = 0;
+
+        if (0xffff - le16_to_cpu(result.gain) > 30)
+                *status |= FE_HAS_SIGNAL;
+        if (result.lock_bits & (1 << 6))
+                *status |= FE_HAS_LOCK;
+        if (result.lock_bits & (1 << 5))
+                *status |= FE_HAS_SYNC;
+        if (result.lock_bits & (1 << 4))
+                *status |= FE_HAS_CARRIER;
+        if (result.lock_bits & (1 << 1))
+                *status |= FE_HAS_VITERBI;
+
+        if ((*status & (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC)) !=
+                        (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC))
+                *status &= ~FE_HAS_LOCK;
+
+        return 0;
+}
+
+static int cinergyt2_fe_read_ber(struct dvb_frontend *fe, u32 *ber)
+{
+        struct cinergyt2_fe_state *state = fe->demodulator_priv;
+        struct dvbt_get_status_msg status;
+        char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
+        int ret;
+
+        ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
+                                sizeof(status), 0);
+        if (ret < 0)
+                return ret;
+
+        *ber = le32_to_cpu(status.viterbi_error_rate);
+        return 0;
+}
+
+static int cinergyt2_fe_read_unc_blocks(struct dvb_frontend *fe, u32 *unc)
+{
+        struct cinergyt2_fe_state *state = fe->demodulator_priv;
+        struct dvbt_get_status_msg status;
+        u8 cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
+        int ret;
+
+        ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (u8 *)&status,
+                                sizeof(status), 0);
+        if (ret < 0) {
+                err("cinergyt2_fe_read_unc_blocks() Failed! (Error=%d)\n",
+                        ret);
+                return ret;
+        }
+        *unc = le32_to_cpu(status.uncorrected_block_count);
+        return 0;
+}
+
+static int cinergyt2_fe_read_signal_strength(struct dvb_frontend *fe,
+                                                u16 *strength)
+{
+        struct cinergyt2_fe_state *state = fe->demodulator_priv;
+        struct dvbt_get_status_msg status;
+        char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
+        int ret;
+
+        ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
+                                sizeof(status), 0);
+        if (ret < 0) {
+                err("cinergyt2_fe_read_signal_strength() Failed!"
+                        " (Error=%d)\n", ret);
+                return ret;
+        }
+        *strength = (0xffff - le16_to_cpu(status.gain));
+        return 0;
+}
+
+static int cinergyt2_fe_read_snr(struct dvb_frontend *fe, u16 *snr)
+{
+        struct cinergyt2_fe_state *state = fe->demodulator_priv;
+        struct dvbt_get_status_msg status;
+        char cmd[] = { CINERGYT2_EP1_GET_TUNER_STATUS };
+        int ret;
+
+        ret = dvb_usb_generic_rw(state->d, cmd, sizeof(cmd), (char *)&status,
+                                sizeof(status), 0);
+        if (ret < 0) {
+                err("cinergyt2_fe_read_snr() Failed! (Error=%d)\n", ret);
+                return ret;
+        }
+        *snr = (status.snr << 8) | status.snr;
+        return 0;
+}
+
+static int cinergyt2_fe_init(struct dvb_frontend *fe)
+{
+        return 0;
+}
+
+static int cinergyt2_fe_sleep(struct dvb_frontend *fe)
+{
+        deb_info("cinergyt2_fe_sleep() Called\n");
+        return 0;
+}
+
+static int cinergyt2_fe_get_tune_settings(struct dvb_frontend *fe,
+                                struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 800;
+        return 0;
+}
+
+static int cinergyt2_fe_set_frontend(struct dvb_frontend *fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct cinergyt2_fe_state *state = fe->demodulator_priv;
+        struct dvbt_set_parameters_msg param;
+        char result[2];
+        int err;
+
+        param.cmd = CINERGYT2_EP1_SET_TUNER_PARAMETERS;
+        param.tps = cpu_to_le16(compute_tps(fep));
+        param.freq = cpu_to_le32(fep->frequency / 1000);
+        param.bandwidth = 8 - fep->u.ofdm.bandwidth - BANDWIDTH_8_MHZ;
+        param.flags = 0;
+
+        err = dvb_usb_generic_rw(state->d,
+                        (char *)&param, sizeof(param),
+                        result, sizeof(result), 0);
+        if (err < 0)
+                err("cinergyt2_fe_set_frontend() Failed! err=%d\n", err);
+
+        return (err < 0) ? err : 0;
+}
+
+static int cinergyt2_fe_get_frontend(struct dvb_frontend *fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        return 0;
+}
+
+static void cinergyt2_fe_release(struct dvb_frontend *fe)
+{
+        struct cinergyt2_fe_state *state = fe->demodulator_priv;
+        if (state != NULL)
+                kfree(state);
+}
+
+static struct dvb_frontend_ops cinergyt2_fe_ops;
+
+struct dvb_frontend *cinergyt2_fe_attach(struct dvb_usb_device *d)
+{
+        struct cinergyt2_fe_state *s = kzalloc(sizeof(
+                                        struct cinergyt2_fe_state), GFP_KERNEL);
+        if (s == NULL)
+                return NULL;
+
+        s->d = d;
+        memcpy(&s->fe.ops, &cinergyt2_fe_ops, sizeof(struct dvb_frontend_ops));
+        s->fe.demodulator_priv = s;
+        return &s->fe;
+}
+
+
+static struct dvb_frontend_ops cinergyt2_fe_ops = {
+        .info = {
+                .name                   = DRIVER_NAME,
+                .type                   = FE_OFDM,
+                .frequency_min          = 174000000,
+                .frequency_max          = 862000000,
+                .frequency_stepsize     = 166667,
+                .caps = FE_CAN_INVERSION_AUTO | FE_CAN_FEC_1_2
+                        | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4
+                        | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8
+                        | FE_CAN_FEC_AUTO | FE_CAN_QPSK
+                        | FE_CAN_QAM_16 | FE_CAN_QAM_64
+                        | FE_CAN_QAM_AUTO
+                        | FE_CAN_TRANSMISSION_MODE_AUTO
+                        | FE_CAN_GUARD_INTERVAL_AUTO
+                        | FE_CAN_HIERARCHY_AUTO
+                        | FE_CAN_RECOVER
+                        | FE_CAN_MUTE_TS
+        },
+
+        .release                = cinergyt2_fe_release,
+
+        .init                   = cinergyt2_fe_init,
+        .sleep                  = cinergyt2_fe_sleep,
+
+        .set_frontend           = cinergyt2_fe_set_frontend,
+        .get_frontend           = cinergyt2_fe_get_frontend,
+        .get_tune_settings      = cinergyt2_fe_get_tune_settings,
+
+        .read_status            = cinergyt2_fe_read_status,
+        .read_ber               = cinergyt2_fe_read_ber,
+        .read_signal_strength   = cinergyt2_fe_read_signal_strength,
+        .read_snr               = cinergyt2_fe_read_snr,
+        .read_ucblocks          = cinergyt2_fe_read_unc_blocks,
+};
diff --git a/drivers/media/dvb/dvb-usb/cinergyT2.h b/drivers/media/dvb/dvb-usb/cinergyT2.h
new file mode 100644
index 00000000000..84efe03771e
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/cinergyT2.h
@@ -0,0 +1,95 @@
+/*
+ * TerraTec Cinergy T2/qanu USB2 DVB-T adapter.
+ *
+ * Copyright (C) 2007 Tomi Orava (tomimo@ncircle.nullnet.fi)
+ *
+ * Based on the dvb-usb-framework code and the
+ * original Terratec Cinergy T2 driver by:
+ *
+ * Copyright (C) 2004 Daniel Mack <daniel@qanu.de> and
+ *                  Holger Waechtler <holger@qanu.de>
+ *
+ *  Protocol Spec published on http://qanu.de/specs/terratec_cinergyT2.pdf
+ *
+ * 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_USB_CINERGYT2_H_
+#define _DVB_USB_CINERGYT2_H_
+
+#include <linux/usb/input.h>
+
+#define DVB_USB_LOG_PREFIX "cinergyT2"
+#include "dvb-usb.h"
+
+#define DRIVER_NAME "TerraTec/qanu USB2.0 Highspeed DVB-T Receiver"
+
+extern int dvb_usb_cinergyt2_debug;
+
+#define deb_info(args...)  dprintk(dvb_usb_cinergyt2_debug,  0x001, args)
+#define deb_xfer(args...)  dprintk(dvb_usb_cinergyt2_debug,  0x002, args)
+#define deb_pll(args...)   dprintk(dvb_usb_cinergyt2_debug,  0x004, args)
+#define deb_ts(args...)    dprintk(dvb_usb_cinergyt2_debug,  0x008, args)
+#define deb_err(args...)   dprintk(dvb_usb_cinergyt2_debug,  0x010, args)
+#define deb_rc(args...)    dprintk(dvb_usb_cinergyt2_debug,  0x020, args)
+#define deb_fw(args...)    dprintk(dvb_usb_cinergyt2_debug,  0x040, args)
+#define deb_mem(args...)   dprintk(dvb_usb_cinergyt2_debug,  0x080, args)
+#define deb_uxfer(args...) dprintk(dvb_usb_cinergyt2_debug,  0x100, args)
+
+
+
+enum cinergyt2_ep1_cmd {
+        CINERGYT2_EP1_PID_TABLE_RESET           = 0x01,
+        CINERGYT2_EP1_PID_SETUP                 = 0x02,
+        CINERGYT2_EP1_CONTROL_STREAM_TRANSFER   = 0x03,
+        CINERGYT2_EP1_SET_TUNER_PARAMETERS      = 0x04,
+        CINERGYT2_EP1_GET_TUNER_STATUS          = 0x05,
+        CINERGYT2_EP1_START_SCAN                = 0x06,
+        CINERGYT2_EP1_CONTINUE_SCAN             = 0x07,
+        CINERGYT2_EP1_GET_RC_EVENTS             = 0x08,
+        CINERGYT2_EP1_SLEEP_MODE                = 0x09,
+        CINERGYT2_EP1_GET_FIRMWARE_VERSION      = 0x0A
+};
+
+
+struct dvbt_get_status_msg {
+        uint32_t freq;
+        uint8_t bandwidth;
+        uint16_t tps;
+        uint8_t flags;
+        __le16 gain;
+        uint8_t snr;
+        __le32 viterbi_error_rate;
+        uint32_t rs_error_rate;
+        __le32 uncorrected_block_count;
+        uint8_t lock_bits;
+        uint8_t prev_lock_bits;
+} __attribute__((packed));
+
+
+struct dvbt_set_parameters_msg {
+        uint8_t cmd;
+        __le32 freq;
+        uint8_t bandwidth;
+        __le16 tps;
+        uint8_t flags;
+} __attribute__((packed));
+
+
+extern struct dvb_frontend *cinergyt2_fe_attach(struct dvb_usb_device *d);
+
+#endif /* _DVB_USB_CINERGYT2_H_ */
+
diff --git a/drivers/media/dvb/dvb-usb/cxusb.c b/drivers/media/dvb/dvb-usb/cxusb.c
new file mode 100644
index 00000000000..acb5fb2d2e7
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/cxusb.c
@@ -0,0 +1,2017 @@
+/* DVB USB compliant linux driver for Conexant USB reference design.
+ *
+ * The Conexant reference design I saw on their website was only for analogue
+ * capturing (using the cx25842). The box I took to write this driver (reverse
+ * engineered) is the one labeled Medion MD95700. In addition to the cx25842
+ * for analogue capturing it also has a cx22702 DVB-T demodulator on the main
+ * board. Besides it has a atiremote (X10) and a USB2.0 hub onboard.
+ *
+ * Maybe it is a little bit premature to call this driver cxusb, but I assume
+ * the USB protocol is identical or at least inherited from the reference
+ * design, so it can be reused for the "analogue-only" device (if it will
+ * appear at all).
+ *
+ * TODO: Use the cx25840-driver for the analogue part
+ *
+ * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@desy.de)
+ * Copyright (C) 2006 Michael Krufky (mkrufky@linuxtv.org)
+ * Copyright (C) 2006, 2007 Chris Pascoe (c.pascoe@itee.uq.edu.au)
+ *
+ *   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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include <media/tuner.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+
+#include "cxusb.h"
+
+#include "cx22702.h"
+#include "lgdt330x.h"
+#include "mt352.h"
+#include "mt352_priv.h"
+#include "zl10353.h"
+#include "tuner-xc2028.h"
+#include "tuner-simple.h"
+#include "mxl5005s.h"
+#include "max2165.h"
+#include "dib7000p.h"
+#include "dib0070.h"
+#include "lgs8gxx.h"
+#include "atbm8830.h"
+
+/* debug */
+static int dvb_usb_cxusb_debug;
+module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+#define deb_info(args...)   dprintk(dvb_usb_cxusb_debug, 0x03, args)
+#define deb_i2c(args...)    dprintk(dvb_usb_cxusb_debug, 0x02, args)
+
+static int cxusb_ctrl_msg(struct dvb_usb_device *d,
+                          u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
+{
+        int wo = (rbuf == NULL || rlen == 0); /* write-only */
+        u8 sndbuf[1+wlen];
+        memset(sndbuf, 0, 1+wlen);
+
+        sndbuf[0] = cmd;
+        memcpy(&sndbuf[1], wbuf, wlen);
+        if (wo)
+                return dvb_usb_generic_write(d, sndbuf, 1+wlen);
+        else
+                return dvb_usb_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen, 0);
+}
+
+/* GPIO */
+static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
+{
+        struct cxusb_state *st = d->priv;
+        u8 o[2], i;
+
+        if (st->gpio_write_state[GPIO_TUNER] == onoff)
+                return;
+
+        o[0] = GPIO_TUNER;
+        o[1] = onoff;
+        cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
+
+        if (i != 0x01)
+                deb_info("gpio_write failed.\n");
+
+        st->gpio_write_state[GPIO_TUNER] = onoff;
+}
+
+static int cxusb_bluebird_gpio_rw(struct dvb_usb_device *d, u8 changemask,
+                                 u8 newval)
+{
+        u8 o[2], gpio_state;
+        int rc;
+
+        o[0] = 0xff & ~changemask;      /* mask of bits to keep */
+        o[1] = newval & changemask;     /* new values for bits  */
+
+        rc = cxusb_ctrl_msg(d, CMD_BLUEBIRD_GPIO_RW, o, 2, &gpio_state, 1);
+        if (rc < 0 || (gpio_state & changemask) != (newval & changemask))
+                deb_info("bluebird_gpio_write failed.\n");
+
+        return rc < 0 ? rc : gpio_state;
+}
+
+static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device *d, u8 pin, int low)
+{
+        cxusb_bluebird_gpio_rw(d, pin, low ? 0 : pin);
+        msleep(5);
+        cxusb_bluebird_gpio_rw(d, pin, low ? pin : 0);
+}
+
+static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff)
+{
+        cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40);
+}
+
+static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d,
+                u8 addr, int onoff)
+{
+        u8  o[2] = {addr, onoff};
+        u8  i;
+        int rc;
+
+        rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
+
+        if (rc < 0)
+                return rc;
+        if (i == 0x01)
+                return 0;
+        else {
+                deb_info("gpio_write failed.\n");
+                return -EIO;
+        }
+}
+
+/* I2C */
+static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                          int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+
+                if (d->udev->descriptor.idVendor == USB_VID_MEDION)
+                        switch (msg[i].addr) {
+                        case 0x63:
+                                cxusb_gpio_tuner(d, 0);
+                                break;
+                        default:
+                                cxusb_gpio_tuner(d, 1);
+                                break;
+                        }
+
+                if (msg[i].flags & I2C_M_RD) {
+                        /* read only */
+                        u8 obuf[3], ibuf[1+msg[i].len];
+                        obuf[0] = 0;
+                        obuf[1] = msg[i].len;
+                        obuf[2] = msg[i].addr;
+                        if (cxusb_ctrl_msg(d, CMD_I2C_READ,
+                                           obuf, 3,
+                                           ibuf, 1+msg[i].len) < 0) {
+                                warn("i2c read failed");
+                                break;
+                        }
+                        memcpy(msg[i].buf, &ibuf[1], msg[i].len);
+                } else if (i+1 < num && (msg[i+1].flags & I2C_M_RD) &&
+                           msg[i].addr == msg[i+1].addr) {
+                        /* write to then read from same address */
+                        u8 obuf[3+msg[i].len], ibuf[1+msg[i+1].len];
+                        obuf[0] = msg[i].len;
+                        obuf[1] = msg[i+1].len;
+                        obuf[2] = msg[i].addr;
+                        memcpy(&obuf[3], msg[i].buf, msg[i].len);
+
+                        if (cxusb_ctrl_msg(d, CMD_I2C_READ,
+                                           obuf, 3+msg[i].len,
+                                           ibuf, 1+msg[i+1].len) < 0)
+                                break;
+
+                        if (ibuf[0] != 0x08)
+                                deb_i2c("i2c read may have failed\n");
+
+                        memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
+
+                        i++;
+                } else {
+                        /* write only */
+                        u8 obuf[2+msg[i].len], ibuf;
+                        obuf[0] = msg[i].addr;
+                        obuf[1] = msg[i].len;
+                        memcpy(&obuf[2], msg[i].buf, msg[i].len);
+
+                        if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf,
+                                           2+msg[i].len, &ibuf,1) < 0)
+                                break;
+                        if (ibuf != 0x08)
+                                deb_i2c("i2c write may have failed\n");
+                }
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i == num ? num : -EREMOTEIO;
+}
+
+static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm cxusb_i2c_algo = {
+        .master_xfer   = cxusb_i2c_xfer,
+        .functionality = cxusb_i2c_func,
+};
+
+static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 b = 0;
+        if (onoff)
+                return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
+        else
+                return cxusb_ctrl_msg(d, CMD_POWER_OFF, &b, 1, NULL, 0);
+}
+
+static int cxusb_aver_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        int ret;
+        if (!onoff)
+                return cxusb_ctrl_msg(d, CMD_POWER_OFF, NULL, 0, NULL, 0);
+        if (d->state == DVB_USB_STATE_INIT &&
+            usb_set_interface(d->udev, 0, 0) < 0)
+                err("set interface failed");
+        do {} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, 0, NULL, 0)) &&
+                   !(ret = cxusb_ctrl_msg(d, 0x15, NULL, 0, NULL, 0)) &&
+                   !(ret = cxusb_ctrl_msg(d, 0x17, NULL, 0, NULL, 0)) && 0);
+        if (!ret) {
+                /* FIXME: We don't know why, but we need to configure the
+                 * lgdt3303 with the register settings below on resume */
+                int i;
+                u8 buf, bufs[] = {
+                        0x0e, 0x2, 0x00, 0x7f,
+                        0x0e, 0x2, 0x02, 0xfe,
+                        0x0e, 0x2, 0x02, 0x01,
+                        0x0e, 0x2, 0x00, 0x03,
+                        0x0e, 0x2, 0x0d, 0x40,
+                        0x0e, 0x2, 0x0e, 0x87,
+                        0x0e, 0x2, 0x0f, 0x8e,
+                        0x0e, 0x2, 0x10, 0x01,
+                        0x0e, 0x2, 0x14, 0xd7,
+                        0x0e, 0x2, 0x47, 0x88,
+                };
+                msleep(20);
+                for (i = 0; i < sizeof(bufs)/sizeof(u8); i += 4/sizeof(u8)) {
+                        ret = cxusb_ctrl_msg(d, CMD_I2C_WRITE,
+                                             bufs+i, 4, &buf, 1);
+                        if (ret)
+                                break;
+                        if (buf != 0x8)
+                                return -EREMOTEIO;
+                }
+        }
+        return ret;
+}
+
+static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 b = 0;
+        if (onoff)
+                return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
+        else
+                return 0;
+}
+
+static int cxusb_nano2_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        int rc = 0;
+
+        rc = cxusb_power_ctrl(d, onoff);
+        if (!onoff)
+                cxusb_nano2_led(d, 0);
+
+        return rc;
+}
+
+static int cxusb_d680_dmb_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        int ret;
+        u8  b;
+        ret = cxusb_power_ctrl(d, onoff);
+        if (!onoff)
+                return ret;
+
+        msleep(128);
+        cxusb_ctrl_msg(d, CMD_DIGITAL, NULL, 0, &b, 1);
+        msleep(100);
+        return ret;
+}
+
+static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        u8 buf[2] = { 0x03, 0x00 };
+        if (onoff)
+                cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0);
+        else
+                cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
+
+        return 0;
+}
+
+static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        if (onoff)
+                cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_ON, NULL, 0, NULL, 0);
+        else
+                cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_OFF,
+                               NULL, 0, NULL, 0);
+        return 0;
+}
+
+static void cxusb_d680_dmb_drain_message(struct dvb_usb_device *d)
+{
+        int       ep = d->props.generic_bulk_ctrl_endpoint;
+        const int timeout = 100;
+        const int junk_len = 32;
+        u8        *junk;
+        int       rd_count;
+
+        /* Discard remaining data in video pipe */
+        junk = kmalloc(junk_len, GFP_KERNEL);
+        if (!junk)
+                return;
+        while (1) {
+                if (usb_bulk_msg(d->udev,
+                        usb_rcvbulkpipe(d->udev, ep),
+                        junk, junk_len, &rd_count, timeout) < 0)
+                        break;
+                if (!rd_count)
+                        break;
+        }
+        kfree(junk);
+}
+
+static void cxusb_d680_dmb_drain_video(struct dvb_usb_device *d)
+{
+        struct usb_data_stream_properties *p = &d->props.adapter[0].stream;
+        const int timeout = 100;
+        const int junk_len = p->u.bulk.buffersize;
+        u8        *junk;
+        int       rd_count;
+
+        /* Discard remaining data in video pipe */
+        junk = kmalloc(junk_len, GFP_KERNEL);
+        if (!junk)
+                return;
+        while (1) {
+                if (usb_bulk_msg(d->udev,
+                        usb_rcvbulkpipe(d->udev, p->endpoint),
+                        junk, junk_len, &rd_count, timeout) < 0)
+                        break;
+                if (!rd_count)
+                        break;
+        }
+        kfree(junk);
+}
+
+static int cxusb_d680_dmb_streaming_ctrl(
+                struct dvb_usb_adapter *adap, int onoff)
+{
+        if (onoff) {
+                u8 buf[2] = { 0x03, 0x00 };
+                cxusb_d680_dmb_drain_video(adap->dev);
+                return cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON,
+                        buf, sizeof(buf), NULL, 0);
+        } else {
+                int ret = cxusb_ctrl_msg(adap->dev,
+                        CMD_STREAMING_OFF, NULL, 0, NULL, 0);
+                return ret;
+        }
+}
+
+static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
+        u8 ircode[4];
+        int i;
+
+        cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4);
+
+        *event = 0;
+        *state = REMOTE_NO_KEY_PRESSED;
+
+        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
+                if (rc5_custom(&keymap[i]) == ircode[2] &&
+                    rc5_data(&keymap[i]) == ircode[3]) {
+                        *event = keymap[i].keycode;
+                        *state = REMOTE_KEY_PRESSED;
+
+                        return 0;
+                }
+        }
+
+        return 0;
+}
+
+static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d, u32 *event,
+                                    int *state)
+{
+        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
+        u8 ircode[4];
+        int i;
+        struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
+                               .buf = ircode, .len = 4 };
+
+        *event = 0;
+        *state = REMOTE_NO_KEY_PRESSED;
+
+        if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1)
+                return 0;
+
+        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
+                if (rc5_custom(&keymap[i]) == ircode[1] &&
+                    rc5_data(&keymap[i]) == ircode[2]) {
+                        *event = keymap[i].keycode;
+                        *state = REMOTE_KEY_PRESSED;
+
+                        return 0;
+                }
+        }
+
+        return 0;
+}
+
+static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
+                int *state)
+{
+        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
+        u8 ircode[2];
+        int i;
+
+        *event = 0;
+        *state = REMOTE_NO_KEY_PRESSED;
+
+        if (cxusb_ctrl_msg(d, 0x10, NULL, 0, ircode, 2) < 0)
+                return 0;
+
+        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
+                if (rc5_custom(&keymap[i]) == ircode[0] &&
+                    rc5_data(&keymap[i]) == ircode[1]) {
+                        *event = keymap[i].keycode;
+                        *state = REMOTE_KEY_PRESSED;
+
+                        return 0;
+                }
+        }
+
+        return 0;
+}
+
+static struct rc_map_table rc_map_dvico_mce_table[] = {
+        { 0xfe02, KEY_TV },
+        { 0xfe0e, KEY_MP3 },
+        { 0xfe1a, KEY_DVD },
+        { 0xfe1e, KEY_FAVORITES },
+        { 0xfe16, KEY_SETUP },
+        { 0xfe46, KEY_POWER2 },
+        { 0xfe0a, KEY_EPG },
+        { 0xfe49, KEY_BACK },
+        { 0xfe4d, KEY_MENU },
+        { 0xfe51, KEY_UP },
+        { 0xfe5b, KEY_LEFT },
+        { 0xfe5f, KEY_RIGHT },
+        { 0xfe53, KEY_DOWN },
+        { 0xfe5e, KEY_OK },
+        { 0xfe59, KEY_INFO },
+        { 0xfe55, KEY_TAB },
+        { 0xfe0f, KEY_PREVIOUSSONG },/* Replay */
+        { 0xfe12, KEY_NEXTSONG },       /* Skip */
+        { 0xfe42, KEY_ENTER      },     /* Windows/Start */
+        { 0xfe15, KEY_VOLUMEUP },
+        { 0xfe05, KEY_VOLUMEDOWN },
+        { 0xfe11, KEY_CHANNELUP },
+        { 0xfe09, KEY_CHANNELDOWN },
+        { 0xfe52, KEY_CAMERA },
+        { 0xfe5a, KEY_TUNER },  /* Live */
+        { 0xfe19, KEY_OPEN },
+        { 0xfe0b, KEY_1 },
+        { 0xfe17, KEY_2 },
+        { 0xfe1b, KEY_3 },
+        { 0xfe07, KEY_4 },
+        { 0xfe50, KEY_5 },
+        { 0xfe54, KEY_6 },
+        { 0xfe48, KEY_7 },
+        { 0xfe4c, KEY_8 },
+        { 0xfe58, KEY_9 },
+        { 0xfe13, KEY_ANGLE },  /* Aspect */
+        { 0xfe03, KEY_0 },
+        { 0xfe1f, KEY_ZOOM },
+        { 0xfe43, KEY_REWIND },
+        { 0xfe47, KEY_PLAYPAUSE },
+        { 0xfe4f, KEY_FASTFORWARD },
+        { 0xfe57, KEY_MUTE },
+        { 0xfe0d, KEY_STOP },
+        { 0xfe01, KEY_RECORD },
+        { 0xfe4e, KEY_POWER },
+};
+
+static struct rc_map_table rc_map_dvico_portable_table[] = {
+        { 0xfc02, KEY_SETUP },       /* Profile */
+        { 0xfc43, KEY_POWER2 },
+        { 0xfc06, KEY_EPG },
+        { 0xfc5a, KEY_BACK },
+        { 0xfc05, KEY_MENU },
+        { 0xfc47, KEY_INFO },
+        { 0xfc01, KEY_TAB },
+        { 0xfc42, KEY_PREVIOUSSONG },/* Replay */
+        { 0xfc49, KEY_VOLUMEUP },
+        { 0xfc09, KEY_VOLUMEDOWN },
+        { 0xfc54, KEY_CHANNELUP },
+        { 0xfc0b, KEY_CHANNELDOWN },
+        { 0xfc16, KEY_CAMERA },
+        { 0xfc40, KEY_TUNER },  /* ATV/DTV */
+        { 0xfc45, KEY_OPEN },
+        { 0xfc19, KEY_1 },
+        { 0xfc18, KEY_2 },
+        { 0xfc1b, KEY_3 },
+        { 0xfc1a, KEY_4 },
+        { 0xfc58, KEY_5 },
+        { 0xfc59, KEY_6 },
+        { 0xfc15, KEY_7 },
+        { 0xfc14, KEY_8 },
+        { 0xfc17, KEY_9 },
+        { 0xfc44, KEY_ANGLE },  /* Aspect */
+        { 0xfc55, KEY_0 },
+        { 0xfc07, KEY_ZOOM },
+        { 0xfc0a, KEY_REWIND },
+        { 0xfc08, KEY_PLAYPAUSE },
+        { 0xfc4b, KEY_FASTFORWARD },
+        { 0xfc5b, KEY_MUTE },
+        { 0xfc04, KEY_STOP },
+        { 0xfc56, KEY_RECORD },
+        { 0xfc57, KEY_POWER },
+        { 0xfc41, KEY_UNKNOWN },    /* INPUT */
+        { 0xfc00, KEY_UNKNOWN },    /* HD */
+};
+
+static struct rc_map_table rc_map_d680_dmb_table[] = {
+        { 0x0038, KEY_UNKNOWN },        /* TV/AV */
+        { 0x080c, KEY_ZOOM },
+        { 0x0800, KEY_0 },
+        { 0x0001, KEY_1 },
+        { 0x0802, KEY_2 },
+        { 0x0003, KEY_3 },
+        { 0x0804, KEY_4 },
+        { 0x0005, KEY_5 },
+        { 0x0806, KEY_6 },
+        { 0x0007, KEY_7 },
+        { 0x0808, KEY_8 },
+        { 0x0009, KEY_9 },
+        { 0x000a, KEY_MUTE },
+        { 0x0829, KEY_BACK },
+        { 0x0012, KEY_CHANNELUP },
+        { 0x0813, KEY_CHANNELDOWN },
+        { 0x002b, KEY_VOLUMEUP },
+        { 0x082c, KEY_VOLUMEDOWN },
+        { 0x0020, KEY_UP },
+        { 0x0821, KEY_DOWN },
+        { 0x0011, KEY_LEFT },
+        { 0x0810, KEY_RIGHT },
+        { 0x000d, KEY_OK },
+        { 0x081f, KEY_RECORD },
+        { 0x0017, KEY_PLAYPAUSE },
+        { 0x0816, KEY_PLAYPAUSE },
+        { 0x000b, KEY_STOP },
+        { 0x0827, KEY_FASTFORWARD },
+        { 0x0026, KEY_REWIND },
+        { 0x081e, KEY_UNKNOWN },    /* Time Shift */
+        { 0x000e, KEY_UNKNOWN },    /* Snapshot */
+        { 0x082d, KEY_UNKNOWN },    /* Mouse Cursor */
+        { 0x000f, KEY_UNKNOWN },    /* Minimize/Maximize */
+        { 0x0814, KEY_UNKNOWN },    /* Shuffle */
+        { 0x0025, KEY_POWER },
+};
+
+static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
+{
+        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x28 };
+        static u8 reset []         = { RESET,      0x80 };
+        static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
+        static u8 agc_cfg []       = { AGC_TARGET, 0x28, 0x20 };
+        static u8 gpp_ctl_cfg []   = { GPP_CTL,    0x33 };
+        static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
+
+        mt352_write(fe, clock_config,   sizeof(clock_config));
+        udelay(200);
+        mt352_write(fe, reset,          sizeof(reset));
+        mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
+
+        mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
+        mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
+        mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
+
+        return 0;
+}
+
+static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
+{       /* used in both lgz201 and th7579 */
+        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x29 };
+        static u8 reset []         = { RESET,      0x80 };
+        static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
+        static u8 agc_cfg []       = { AGC_TARGET, 0x24, 0x20 };
+        static u8 gpp_ctl_cfg []   = { GPP_CTL,    0x33 };
+        static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
+
+        mt352_write(fe, clock_config,   sizeof(clock_config));
+        udelay(200);
+        mt352_write(fe, reset,          sizeof(reset));
+        mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
+
+        mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
+        mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
+        mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
+        return 0;
+}
+
+static struct cx22702_config cxusb_cx22702_config = {
+        .demod_address = 0x63,
+        .output_mode = CX22702_PARALLEL_OUTPUT,
+};
+
+static struct lgdt330x_config cxusb_lgdt3303_config = {
+        .demod_address = 0x0e,
+        .demod_chip    = LGDT3303,
+};
+
+static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
+        .demod_address       = 0x0e,
+        .demod_chip          = LGDT3303,
+        .clock_polarity_flip = 2,
+};
+
+static struct mt352_config cxusb_dee1601_config = {
+        .demod_address = 0x0f,
+        .demod_init    = cxusb_dee1601_demod_init,
+};
+
+static struct zl10353_config cxusb_zl10353_dee1601_config = {
+        .demod_address = 0x0f,
+        .parallel_ts = 1,
+};
+
+static struct mt352_config cxusb_mt352_config = {
+        /* used in both lgz201 and th7579 */
+        .demod_address = 0x0f,
+        .demod_init    = cxusb_mt352_demod_init,
+};
+
+static struct zl10353_config cxusb_zl10353_xc3028_config = {
+        .demod_address = 0x0f,
+        .if2 = 45600,
+        .no_tuner = 1,
+        .parallel_ts = 1,
+};
+
+static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = {
+        .demod_address = 0x0f,
+        .if2 = 45600,
+        .no_tuner = 1,
+        .parallel_ts = 1,
+        .disable_i2c_gate_ctrl = 1,
+};
+
+static struct mt352_config cxusb_mt352_xc3028_config = {
+        .demod_address = 0x0f,
+        .if2 = 4560,
+        .no_tuner = 1,
+        .demod_init = cxusb_mt352_demod_init,
+};
+
+/* FIXME: needs tweaking */
+static struct mxl5005s_config aver_a868r_tuner = {
+        .i2c_address     = 0x63,
+        .if_freq         = 6000000UL,
+        .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
+        .agc_mode        = MXL_SINGLE_AGC,
+        .tracking_filter = MXL_TF_C,
+        .rssi_enable     = MXL_RSSI_ENABLE,
+        .cap_select      = MXL_CAP_SEL_ENABLE,
+        .div_out         = MXL_DIV_OUT_4,
+        .clock_out       = MXL_CLOCK_OUT_DISABLE,
+        .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
+        .top             = MXL5005S_TOP_25P2,
+        .mod_mode        = MXL_DIGITAL_MODE,
+        .if_mode         = MXL_ZERO_IF,
+        .AgcMasterByte   = 0x00,
+};
+
+/* FIXME: needs tweaking */
+static struct mxl5005s_config d680_dmb_tuner = {
+        .i2c_address     = 0x63,
+        .if_freq         = 36125000UL,
+        .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
+        .agc_mode        = MXL_SINGLE_AGC,
+        .tracking_filter = MXL_TF_C,
+        .rssi_enable     = MXL_RSSI_ENABLE,
+        .cap_select      = MXL_CAP_SEL_ENABLE,
+        .div_out         = MXL_DIV_OUT_4,
+        .clock_out       = MXL_CLOCK_OUT_DISABLE,
+        .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
+        .top             = MXL5005S_TOP_25P2,
+        .mod_mode        = MXL_DIGITAL_MODE,
+        .if_mode         = MXL_ZERO_IF,
+        .AgcMasterByte   = 0x00,
+};
+
+static struct max2165_config mygica_d689_max2165_cfg = {
+        .i2c_address = 0x60,
+        .osc_clk = 20
+};
+
+/* Callbacks for DVB USB */
+static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(simple_tuner_attach, adap->fe,
+                   &adap->dev->i2c_adap, 0x61,
+                   TUNER_PHILIPS_FMD1216ME_MK3);
+        return 0;
+}
+
+static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(dvb_pll_attach, adap->fe, 0x61,
+                   NULL, DVB_PLL_THOMSON_DTT7579);
+        return 0;
+}
+
+static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(dvb_pll_attach, adap->fe, 0x61, NULL, DVB_PLL_LG_Z201);
+        return 0;
+}
+
+static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(dvb_pll_attach, adap->fe, 0x60,
+                   NULL, DVB_PLL_THOMSON_DTT7579);
+        return 0;
+}
+
+static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(simple_tuner_attach, adap->fe,
+                   &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
+        return 0;
+}
+
+static int dvico_bluebird_xc2028_callback(void *ptr, int component,
+                                          int command, int arg)
+{
+        struct dvb_usb_adapter *adap = ptr;
+        struct dvb_usb_device *d = adap->dev;
+
+        switch (command) {
+        case XC2028_TUNER_RESET:
+                deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
+                cxusb_bluebird_gpio_pulse(d, 0x01, 1);
+                break;
+        case XC2028_RESET_CLK:
+                deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
+                break;
+        default:
+                deb_info("%s: unknown command %d, arg %d\n", __func__,
+                         command, arg);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvb_frontend      *fe;
+        struct xc2028_config      cfg = {
+                .i2c_adap  = &adap->dev->i2c_adap,
+                .i2c_addr  = 0x61,
+        };
+        static struct xc2028_ctrl ctl = {
+                .fname       = XC2028_DEFAULT_FIRMWARE,
+                .max_len     = 64,
+                .demod       = XC3028_FE_ZARLINK456,
+        };
+
+        /* FIXME: generalize & move to common area */
+        adap->fe->callback = dvico_bluebird_xc2028_callback;
+
+        fe = dvb_attach(xc2028_attach, adap->fe, &cfg);
+        if (fe == NULL || fe->ops.tuner_ops.set_config == NULL)
+                return -EIO;
+
+        fe->ops.tuner_ops.set_config(fe, &ctl);
+
+        return 0;
+}
+
+static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(mxl5005s_attach, adap->fe,
+                   &adap->dev->i2c_adap, &aver_a868r_tuner);
+        return 0;
+}
+
+static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvb_frontend *fe;
+        fe = dvb_attach(mxl5005s_attach, adap->fe,
+                        &adap->dev->i2c_adap, &d680_dmb_tuner);
+        return (fe == NULL) ? -EIO : 0;
+}
+
+static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvb_frontend *fe;
+        fe = dvb_attach(max2165_attach, adap->fe,
+                        &adap->dev->i2c_adap, &mygica_d689_max2165_cfg);
+        return (fe == NULL) ? -EIO : 0;
+}
+
+static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        u8 b;
+        if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
+                err("set interface failed");
+
+        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
+
+        if ((adap->fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
+                                   &adap->dev->i2c_adap)) != NULL)
+                return 0;
+
+        return -EIO;
+}
+
+static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
+                err("set interface failed");
+
+        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
+
+        if ((adap->fe = dvb_attach(lgdt330x_attach, &cxusb_lgdt3303_config,
+                                   &adap->dev->i2c_adap)) != NULL)
+                return 0;
+
+        return -EIO;
+}
+
+static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        adap->fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
+                              &adap->dev->i2c_adap);
+        if (adap->fe != NULL)
+                return 0;
+
+        return -EIO;
+}
+
+static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        /* used in both lgz201 and th7579 */
+        if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
+                err("set interface failed");
+
+        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
+
+        if ((adap->fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
+                                   &adap->dev->i2c_adap)) != NULL)
+                return 0;
+
+        return -EIO;
+}
+
+static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
+                err("set interface failed");
+
+        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
+
+        if (((adap->fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
+                                    &adap->dev->i2c_adap)) != NULL) ||
+                ((adap->fe = dvb_attach(zl10353_attach,
+                                        &cxusb_zl10353_dee1601_config,
+                                        &adap->dev->i2c_adap)) != NULL))
+                return 0;
+
+        return -EIO;
+}
+
+static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        u8 ircode[4];
+        int i;
+        struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
+                               .buf = ircode, .len = 4 };
+
+        if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
+                err("set interface failed");
+
+        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
+
+        /* reset the tuner and demodulator */
+        cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
+        cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
+        cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
+
+        if ((adap->fe = dvb_attach(zl10353_attach,
+                                   &cxusb_zl10353_xc3028_config_no_i2c_gate,
+                                   &adap->dev->i2c_adap)) == NULL)
+                return -EIO;
+
+        /* try to determine if there is no IR decoder on the I2C bus */
+        for (i = 0; adap->dev->props.rc.legacy.rc_map_table != NULL && i < 5; i++) {
+                msleep(20);
+                if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
+                        goto no_IR;
+                if (ircode[0] == 0 && ircode[1] == 0)
+                        continue;
+                if (ircode[2] + ircode[3] != 0xff) {
+no_IR:
+                        adap->dev->props.rc.legacy.rc_map_table = NULL;
+                        info("No IR receiver detected on this device.");
+                        break;
+                }
+        }
+
+        return 0;
+}
+
+static struct dibx000_agc_config dib7070_agc_config = {
+        .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
+
+        /*
+         * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
+         * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
+         * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
+         */
+        .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
+                 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
+        .inv_gain = 600,
+        .time_stabiliz = 10,
+        .alpha_level = 0,
+        .thlock = 118,
+        .wbd_inv = 0,
+        .wbd_ref = 3530,
+        .wbd_sel = 1,
+        .wbd_alpha = 5,
+        .agc1_max = 65535,
+        .agc1_min = 0,
+        .agc2_max = 65535,
+        .agc2_min = 0,
+        .agc1_pt1 = 0,
+        .agc1_pt2 = 40,
+        .agc1_pt3 = 183,
+        .agc1_slope1 = 206,
+        .agc1_slope2 = 255,
+        .agc2_pt1 = 72,
+        .agc2_pt2 = 152,
+        .agc2_slope1 = 88,
+        .agc2_slope2 = 90,
+        .alpha_mant = 17,
+        .alpha_exp = 27,
+        .beta_mant = 23,
+        .beta_exp = 51,
+        .perform_agc_softsplit = 0,
+};
+
+static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
+        .internal = 60000,
+        .sampling = 15000,
+        .pll_prediv = 1,
+        .pll_ratio = 20,
+        .pll_range = 3,
+        .pll_reset = 1,
+        .pll_bypass = 0,
+        .enable_refdiv = 0,
+        .bypclk_div = 0,
+        .IO_CLK_en_core = 1,
+        .ADClkSrc = 1,
+        .modulo = 2,
+        /* refsel, sel, freq_15k */
+        .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
+        .ifreq = (0 << 25) | 0,
+        .timf = 20452225,
+        .xtal_hz = 12000000,
+};
+
+static struct dib7000p_config cxusb_dualdig4_rev2_config = {
+        .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_config_count = 1,
+        .agc = &dib7070_agc_config,
+        .bw  = &dib7070_bw_config_12_mhz,
+        .tuner_is_baseband = 1,
+        .spur_protect = 1,
+
+        .gpio_dir = 0xfcef,
+        .gpio_val = 0x0110,
+
+        .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+
+        .hostbus_diversity = 1,
+};
+
+static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
+                err("set interface failed");
+
+        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
+
+        cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
+
+        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                                     &cxusb_dualdig4_rev2_config) < 0) {
+                printk(KERN_WARNING "Unable to enumerate dib7000p\n");
+                return -ENODEV;
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+                              &cxusb_dualdig4_rev2_config);
+        if (adap->fe == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
+{
+        return dib7000p_set_gpio(fe, 8, 0, !onoff);
+}
+
+static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
+{
+        return 0;
+}
+
+static struct dib0070_config dib7070p_dib0070_config = {
+        .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+        .reset = dib7070_tuner_reset,
+        .sleep = dib7070_tuner_sleep,
+        .clock_khz = 12000,
+};
+
+struct dib0700_adapter_state {
+        int (*set_param_save) (struct dvb_frontend *,
+                               struct dvb_frontend_parameters *);
+};
+
+static int dib7070_set_param_override(struct dvb_frontend *fe,
+                                      struct dvb_frontend_parameters *fep)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        u16 offset;
+        u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
+        switch (band) {
+        case BAND_VHF: offset = 950; break;
+        default:
+        case BAND_UHF: offset = 550; break;
+        }
+
+        dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
+
+        return state->set_param_save(fe, fep);
+}
+
+static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c =
+                dib7000p_get_i2c_master(adap->fe,
+                                        DIBX000_I2C_INTERFACE_TUNER, 1);
+
+        if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
+            &dib7070p_dib0070_config) == NULL)
+                return -ENODEV;
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
+        return 0;
+}
+
+static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
+                err("set interface failed");
+
+        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
+
+        /* reset the tuner and demodulator */
+        cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
+        cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
+        cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
+
+        if ((adap->fe = dvb_attach(zl10353_attach,
+                                   &cxusb_zl10353_xc3028_config,
+                                   &adap->dev->i2c_adap)) != NULL)
+                return 0;
+
+        if ((adap->fe = dvb_attach(mt352_attach,
+                                   &cxusb_mt352_xc3028_config,
+                                   &adap->dev->i2c_adap)) != NULL)
+                return 0;
+
+        return -EIO;
+}
+
+static struct lgs8gxx_config d680_lgs8gl5_cfg = {
+        .prod = LGS8GXX_PROD_LGS8GL5,
+        .demod_address = 0x19,
+        .serial_ts = 0,
+        .ts_clk_pol = 0,
+        .ts_clk_gated = 1,
+        .if_clk_freq = 30400, /* 30.4 MHz */
+        .if_freq = 5725, /* 5.725 MHz */
+        .if_neg_center = 0,
+        .ext_adc = 0,
+        .adc_signed = 0,
+        .if_neg_edge = 0,
+};
+
+static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvb_usb_device *d = adap->dev;
+        int n;
+
+        /* Select required USB configuration */
+        if (usb_set_interface(d->udev, 0, 0) < 0)
+                err("set interface failed");
+
+        /* Unblock all USB pipes */
+        usb_clear_halt(d->udev,
+                usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
+        usb_clear_halt(d->udev,
+                usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
+        usb_clear_halt(d->udev,
+                usb_rcvbulkpipe(d->udev, d->props.adapter[0].stream.endpoint));
+
+        /* Drain USB pipes to avoid hang after reboot */
+        for (n = 0;  n < 5;  n++) {
+                cxusb_d680_dmb_drain_message(d);
+                cxusb_d680_dmb_drain_video(d);
+                msleep(200);
+        }
+
+        /* Reset the tuner */
+        if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
+                err("clear tuner gpio failed");
+                return -EIO;
+        }
+        msleep(100);
+        if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
+                err("set tuner gpio failed");
+                return -EIO;
+        }
+        msleep(100);
+
+        /* Attach frontend */
+        adap->fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap);
+        if (adap->fe == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+static struct atbm8830_config mygica_d689_atbm8830_cfg = {
+        .prod = ATBM8830_PROD_8830,
+        .demod_address = 0x40,
+        .serial_ts = 0,
+        .ts_sampling_edge = 1,
+        .ts_clk_gated = 0,
+        .osc_clk_freq = 30400, /* in kHz */
+        .if_freq = 0, /* zero IF */
+        .zif_swap_iq = 1,
+        .agc_min = 0x2E,
+        .agc_max = 0x90,
+        .agc_hold_loop = 0,
+};
+
+static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvb_usb_device *d = adap->dev;
+
+        /* Select required USB configuration */
+        if (usb_set_interface(d->udev, 0, 0) < 0)
+                err("set interface failed");
+
+        /* Unblock all USB pipes */
+        usb_clear_halt(d->udev,
+                usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
+        usb_clear_halt(d->udev,
+                usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
+        usb_clear_halt(d->udev,
+                usb_rcvbulkpipe(d->udev, d->props.adapter[0].stream.endpoint));
+
+
+        /* Reset the tuner */
+        if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
+                err("clear tuner gpio failed");
+                return -EIO;
+        }
+        msleep(100);
+        if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
+                err("set tuner gpio failed");
+                return -EIO;
+        }
+        msleep(100);
+
+        /* Attach frontend */
+        adap->fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg,
+                &d->i2c_adap);
+        if (adap->fe == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+/*
+ * DViCO has shipped two devices with the same USB ID, but only one of them
+ * needs a firmware download.  Check the device class details to see if they
+ * have non-default values to decide whether the device is actually cold or
+ * not, and forget a match if it turns out we selected the wrong device.
+ */
+static int bluebird_fx2_identify_state(struct usb_device *udev,
+                                       struct dvb_usb_device_properties *props,
+                                       struct dvb_usb_device_description **desc,
+                                       int *cold)
+{
+        int wascold = *cold;
+
+        *cold = udev->descriptor.bDeviceClass == 0xff &&
+                udev->descriptor.bDeviceSubClass == 0xff &&
+                udev->descriptor.bDeviceProtocol == 0xff;
+
+        if (*cold && !wascold)
+                *desc = NULL;
+
+        return 0;
+}
+
+/*
+ * DViCO bluebird firmware needs the "warm" product ID to be patched into the
+ * firmware file before download.
+ */
+
+static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
+static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
+                                                  const struct firmware *fw)
+{
+        int pos;
+
+        for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
+                int idoff = dvico_firmware_id_offsets[pos];
+
+                if (fw->size < idoff + 4)
+                        continue;
+
+                if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
+                    fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
+                        struct firmware new_fw;
+                        u8 *new_fw_data = vmalloc(fw->size);
+                        int ret;
+
+                        if (!new_fw_data)
+                                return -ENOMEM;
+
+                        memcpy(new_fw_data, fw->data, fw->size);
+                        new_fw.size = fw->size;
+                        new_fw.data = new_fw_data;
+
+                        new_fw_data[idoff + 2] =
+                                le16_to_cpu(udev->descriptor.idProduct) + 1;
+                        new_fw_data[idoff + 3] =
+                                le16_to_cpu(udev->descriptor.idProduct) >> 8;
+
+                        ret = usb_cypress_load_firmware(udev, &new_fw,
+                                                        CYPRESS_FX2);
+                        vfree(new_fw_data);
+                        return ret;
+                }
+        }
+
+        return -EINVAL;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties cxusb_medion_properties;
+static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
+static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
+static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
+static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
+static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
+static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
+static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
+static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
+static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
+static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
+static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
+
+static int cxusb_probe(struct usb_interface *intf,
+                       const struct usb_device_id *id)
+{
+        if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf,
+                                &cxusb_bluebird_nano2_needsfirmware_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf,
+                                     &cxusb_bluebird_dualdig4_rev2_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0)
+                return 0;
+
+        return -EINVAL;
+}
+
+static struct usb_device_id cxusb_table [] = {
+        { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) },
+        { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) },
+        { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
+        { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
+        { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) },
+        {}              /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, cxusb_table);
+
+static struct dvb_usb_device_properties cxusb_medion_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        .frontend_attach  = cxusb_cx22702_frontend_attach,
+                        .tuner_attach     = cxusb_fmd1216me_tuner_attach,
+                        /* parameter for the MPEG2-data transfer */
+                                        .stream = {
+                                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+
+                },
+        },
+        .power_ctrl       = cxusb_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "Medion MD95700 (MDUSBTV-HYBRID)",
+                        { NULL },
+                        { &cxusb_table[0], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl          = DEVICE_SPECIFIC,
+        .firmware          = "dvb-usb-bluebird-01.fw",
+        .download_firmware = bluebird_patch_dvico_firmware_download,
+        /* use usb alt setting 0 for EP4 transfer (dvb-t),
+           use usb alt setting 7 for EP2 transfer (atsc) */
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        .frontend_attach  = cxusb_lgdt3303_frontend_attach,
+                        .tuner_attach     = cxusb_lgh064f_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                                        .stream = {
+                                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+
+        .power_ctrl       = cxusb_bluebird_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_dvico_portable_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
+                .rc_query         = cxusb_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "DViCO FusionHDTV5 USB Gold",
+                        { &cxusb_table[1], NULL },
+                        { &cxusb_table[2], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl          = DEVICE_SPECIFIC,
+        .firmware          = "dvb-usb-bluebird-01.fw",
+        .download_firmware = bluebird_patch_dvico_firmware_download,
+        /* use usb alt setting 0 for EP4 transfer (dvb-t),
+           use usb alt setting 7 for EP2 transfer (atsc) */
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        .frontend_attach  = cxusb_dee1601_frontend_attach,
+                        .tuner_attach     = cxusb_dee1601_tuner_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x04,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+
+        .power_ctrl       = cxusb_bluebird_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .rc.legacy = {
+                .rc_interval      = 150,
+                .rc_map_table     = rc_map_dvico_mce_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_mce_table),
+                .rc_query         = cxusb_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 3,
+        .devices = {
+                {   "DViCO FusionHDTV DVB-T Dual USB",
+                        { &cxusb_table[3], NULL },
+                        { &cxusb_table[4], NULL },
+                },
+                {   "DigitalNow DVB-T Dual USB",
+                        { &cxusb_table[9],  NULL },
+                        { &cxusb_table[10], NULL },
+                },
+                {   "DViCO FusionHDTV DVB-T Dual Digital 2",
+                        { &cxusb_table[11], NULL },
+                        { &cxusb_table[12], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl          = DEVICE_SPECIFIC,
+        .firmware          = "dvb-usb-bluebird-01.fw",
+        .download_firmware = bluebird_patch_dvico_firmware_download,
+        /* use usb alt setting 0 for EP4 transfer (dvb-t),
+           use usb alt setting 7 for EP2 transfer (atsc) */
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 2,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        .frontend_attach  = cxusb_mt352_frontend_attach,
+                        .tuner_attach     = cxusb_lgz201_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x04,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+        .power_ctrl       = cxusb_bluebird_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_dvico_portable_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
+                .rc_query         = cxusb_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+        .num_device_descs = 1,
+        .devices = {
+                {   "DViCO FusionHDTV DVB-T USB (LGZ201)",
+                        { &cxusb_table[5], NULL },
+                        { &cxusb_table[6], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl          = DEVICE_SPECIFIC,
+        .firmware          = "dvb-usb-bluebird-01.fw",
+        .download_firmware = bluebird_patch_dvico_firmware_download,
+        /* use usb alt setting 0 for EP4 transfer (dvb-t),
+           use usb alt setting 7 for EP2 transfer (atsc) */
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        .frontend_attach  = cxusb_mt352_frontend_attach,
+                        .tuner_attach     = cxusb_dtt7579_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x04,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+        .power_ctrl       = cxusb_bluebird_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_dvico_portable_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
+                .rc_query         = cxusb_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "DViCO FusionHDTV DVB-T USB (TH7579)",
+                        { &cxusb_table[7], NULL },
+                        { &cxusb_table[8], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl         = CYPRESS_FX2,
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        .frontend_attach  = cxusb_dualdig4_frontend_attach,
+                        .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+
+        .power_ctrl       = cxusb_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_dvico_mce_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_mce_table),
+                .rc_query         = cxusb_bluebird2_rc_query,
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "DViCO FusionHDTV DVB-T Dual Digital 4",
+                        { NULL },
+                        { &cxusb_table[13], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl         = CYPRESS_FX2,
+        .identify_state   = bluebird_fx2_identify_state,
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        .frontend_attach  = cxusb_nano2_frontend_attach,
+                        .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+
+        .power_ctrl       = cxusb_nano2_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_dvico_portable_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
+                .rc_query         = cxusb_bluebird2_rc_query,
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "DViCO FusionHDTV DVB-T NANO2",
+                        { NULL },
+                        { &cxusb_table[14], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl          = DEVICE_SPECIFIC,
+        .firmware          = "dvb-usb-bluebird-02.fw",
+        .download_firmware = bluebird_patch_dvico_firmware_download,
+        .identify_state    = bluebird_fx2_identify_state,
+
+        .size_of_priv      = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_streaming_ctrl,
+                        .frontend_attach  = cxusb_nano2_frontend_attach,
+                        .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+
+        .power_ctrl       = cxusb_nano2_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_dvico_portable_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
+                .rc_query         = cxusb_rc_query,
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
+                        { &cxusb_table[14], NULL },
+                        { &cxusb_table[15], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl         = CYPRESS_FX2,
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_aver_streaming_ctrl,
+                        .frontend_attach  = cxusb_aver_lgdt3303_frontend_attach,
+                        .tuner_attach     = cxusb_mxl5003s_tuner_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x04,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+
+                },
+        },
+        .power_ctrl       = cxusb_aver_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "AVerMedia AVerTVHD Volar (A868R)",
+                        { NULL },
+                        { &cxusb_table[16], NULL },
+                },
+        }
+};
+
+static
+struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl         = CYPRESS_FX2,
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl  = cxusb_streaming_ctrl,
+                        .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
+                        .tuner_attach    = cxusb_dualdig4_rev2_tuner_attach,
+                        .size_of_priv    = sizeof(struct dib0700_adapter_state),
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                },
+        },
+
+        .power_ctrl       = cxusb_bluebird_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_dvico_mce_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_mce_table),
+                .rc_query         = cxusb_rc_query,
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
+                        { NULL },
+                        { &cxusb_table[17], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl         = CYPRESS_FX2,
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_d680_dmb_streaming_ctrl,
+                        .frontend_attach  = cxusb_d680_dmb_frontend_attach,
+                        .tuner_attach     = cxusb_d680_dmb_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+
+        .power_ctrl       = cxusb_d680_dmb_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_d680_dmb_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_d680_dmb_table),
+                .rc_query         = cxusb_d680_dmb_rc_query,
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        "Conexant DMB-TH Stick",
+                        { NULL },
+                        { &cxusb_table[18], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl         = CYPRESS_FX2,
+
+        .size_of_priv     = sizeof(struct cxusb_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = cxusb_d680_dmb_streaming_ctrl,
+                        .frontend_attach  = cxusb_mygica_d689_frontend_attach,
+                        .tuner_attach     = cxusb_mygica_d689_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                },
+        },
+
+        .power_ctrl       = cxusb_d680_dmb_power_ctrl,
+
+        .i2c_algo         = &cxusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_d680_dmb_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_d680_dmb_table),
+                .rc_query         = cxusb_d680_dmb_rc_query,
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        "Mygica D689 DMB-TH",
+                        { NULL },
+                        { &cxusb_table[19], NULL },
+                },
+        }
+};
+
+static struct usb_driver cxusb_driver = {
+        .name           = "dvb_usb_cxusb",
+        .probe          = cxusb_probe,
+        .disconnect     = dvb_usb_device_exit,
+        .id_table       = cxusb_table,
+};
+
+/* module stuff */
+static int __init cxusb_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&cxusb_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit cxusb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&cxusb_driver);
+}
+
+module_init (cxusb_module_init);
+module_exit (cxusb_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
+MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
+MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
+MODULE_VERSION("1.0-alpha");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/cxusb.h b/drivers/media/dvb/dvb-usb/cxusb.h
new file mode 100644
index 00000000000..1a51eafd31b
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/cxusb.h
@@ -0,0 +1,35 @@
+#ifndef _DVB_USB_CXUSB_H_
+#define _DVB_USB_CXUSB_H_
+
+#define DVB_USB_LOG_PREFIX "cxusb"
+#include "dvb-usb.h"
+
+/* usb commands - some of it are guesses, don't have a reference yet */
+#define CMD_BLUEBIRD_GPIO_RW 0x05
+
+#define CMD_I2C_WRITE     0x08
+#define CMD_I2C_READ      0x09
+
+#define CMD_GPIO_READ     0x0d
+#define CMD_GPIO_WRITE    0x0e
+#define     GPIO_TUNER         0x02
+
+#define CMD_POWER_OFF     0xdc
+#define CMD_POWER_ON      0xde
+
+#define CMD_STREAMING_ON  0x36
+#define CMD_STREAMING_OFF 0x37
+
+#define CMD_AVER_STREAM_ON  0x18
+#define CMD_AVER_STREAM_OFF 0x19
+
+#define CMD_GET_IR_CODE   0x47
+
+#define CMD_ANALOG        0x50
+#define CMD_DIGITAL       0x51
+
+struct cxusb_state {
+        u8 gpio_write_state[3];
+};
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dib0700.h b/drivers/media/dvb/dvb-usb/dib0700.h
new file mode 100644
index 00000000000..9bd6d51b3b9
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dib0700.h
@@ -0,0 +1,73 @@
+/* Linux driver for devices based on the DiBcom DiB0700 USB bridge
+ *
+ *      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, version 2.
+ *
+ *  Copyright (C) 2005-6 DiBcom, SA
+ */
+#ifndef _DIB0700_H_
+#define _DIB0700_H_
+
+#define DVB_USB_LOG_PREFIX "dib0700"
+#include "dvb-usb.h"
+
+#include "dib07x0.h"
+
+extern int dvb_usb_dib0700_debug;
+#define deb_info(args...)   dprintk(dvb_usb_dib0700_debug,0x01,args)
+#define deb_fw(args...)     dprintk(dvb_usb_dib0700_debug,0x02,args)
+#define deb_fwdata(args...) dprintk(dvb_usb_dib0700_debug,0x04,args)
+#define deb_data(args...)   dprintk(dvb_usb_dib0700_debug,0x08,args)
+
+#define REQUEST_SET_USB_XFER_LEN    0x0 /* valid only for firmware version */
+                                        /* higher than 1.21 */
+#define REQUEST_I2C_READ            0x2
+#define REQUEST_I2C_WRITE           0x3
+#define REQUEST_POLL_RC             0x4 /* deprecated in firmware v1.20 */
+#define REQUEST_JUMPRAM             0x8
+#define REQUEST_SET_CLOCK           0xB
+#define REQUEST_SET_GPIO            0xC
+#define REQUEST_ENABLE_VIDEO        0xF
+        // 1 Byte: 4MSB(1 = enable streaming, 0 = disable streaming) 4LSB(Video Mode: 0 = MPEG2 188Bytes, 1 = Analog)
+        // 2 Byte: MPEG2 mode:  4MSB(1 = Master Mode, 0 = Slave Mode) 4LSB(Channel 1 = bit0, Channel 2 = bit1)
+        // 2 Byte: Analog mode: 4MSB(0 = 625 lines, 1 = 525 lines)    4LSB(     "                "           )
+#define REQUEST_SET_I2C_PARAM       0x10
+#define REQUEST_SET_RC              0x11
+#define REQUEST_NEW_I2C_READ        0x12
+#define REQUEST_NEW_I2C_WRITE       0x13
+#define REQUEST_GET_VERSION         0x15
+
+struct dib0700_state {
+        u8 channel_state;
+        u16 mt2060_if1[2];
+        u8 rc_toggle;
+        u8 rc_counter;
+        u8 is_dib7000pc;
+        u8 fw_use_new_i2c_api;
+        u8 disable_streaming_master_mode;
+        u32 fw_version;
+        u32 nb_packet_buffer_size;
+        u8 buf[255];
+};
+
+extern int dib0700_get_version(struct dvb_usb_device *d, u32 *hwversion,
+                               u32 *romversion, u32 *ramversion, u32 *fwtype);
+extern int dib0700_set_gpio(struct dvb_usb_device *, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val);
+extern int dib0700_ctrl_clock(struct dvb_usb_device *d, u32 clk_MHz, u8 clock_out_gp3);
+extern int dib0700_ctrl_rd(struct dvb_usb_device *d, u8 *tx, u8 txlen, u8 *rx, u8 rxlen);
+extern int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw);
+extern int dib0700_rc_setup(struct dvb_usb_device *d);
+extern int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff);
+extern struct i2c_algorithm dib0700_i2c_algo;
+extern int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props,
+                        struct dvb_usb_device_description **desc, int *cold);
+extern int dib0700_change_protocol(struct rc_dev *dev, u64 rc_type);
+extern int dib0700_set_i2c_speed(struct dvb_usb_device *d, u16 scl_kHz);
+
+extern int dib0700_device_count;
+extern int dvb_usb_dib0700_ir_proto;
+extern struct dvb_usb_device_properties dib0700_devices[];
+extern struct usb_device_id dib0700_usb_id_table[];
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dib0700_core.c b/drivers/media/dvb/dvb-usb/dib0700_core.c
new file mode 100644
index 00000000000..a224e94325b
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dib0700_core.c
@@ -0,0 +1,860 @@
+/* Linux driver for devices based on the DiBcom DiB0700 USB bridge
+ *
+ *      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, version 2.
+ *
+ *  Copyright (C) 2005-6 DiBcom, SA
+ */
+#include "dib0700.h"
+
+/* debug */
+int dvb_usb_dib0700_debug;
+module_param_named(debug,dvb_usb_dib0700_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info,2=fw,4=fwdata,8=data (or-able))." DVB_USB_DEBUG_STATUS);
+
+static int nb_packet_buffer_size = 21;
+module_param(nb_packet_buffer_size, int, 0644);
+MODULE_PARM_DESC(nb_packet_buffer_size,
+        "Set the dib0700 driver data buffer size. This parameter "
+        "corresponds to the number of TS packets. The actual size of "
+        "the data buffer corresponds to this parameter "
+        "multiplied by 188 (default: 21)");
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+
+int dib0700_get_version(struct dvb_usb_device *d, u32 *hwversion,
+                        u32 *romversion, u32 *ramversion, u32 *fwtype)
+{
+        struct dib0700_state *st = d->priv;
+        int ret;
+
+        if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+                deb_info("could not acquire lock");
+                return 0;
+        }
+
+        ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
+                                  REQUEST_GET_VERSION,
+                                  USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
+                                  st->buf, 16, USB_CTRL_GET_TIMEOUT);
+        if (hwversion != NULL)
+                *hwversion  = (st->buf[0] << 24)  | (st->buf[1] << 16)  |
+                        (st->buf[2] << 8)  | st->buf[3];
+        if (romversion != NULL)
+                *romversion = (st->buf[4] << 24)  | (st->buf[5] << 16)  |
+                        (st->buf[6] << 8)  | st->buf[7];
+        if (ramversion != NULL)
+                *ramversion = (st->buf[8] << 24)  | (st->buf[9] << 16)  |
+                        (st->buf[10] << 8) | st->buf[11];
+        if (fwtype != NULL)
+                *fwtype     = (st->buf[12] << 24) | (st->buf[13] << 16) |
+                        (st->buf[14] << 8) | st->buf[15];
+        mutex_unlock(&d->usb_mutex);
+        return ret;
+}
+
+/* expecting rx buffer: request data[0] data[1] ... data[2] */
+static int dib0700_ctrl_wr(struct dvb_usb_device *d, u8 *tx, u8 txlen)
+{
+        int status;
+
+        deb_data(">>> ");
+        debug_dump(tx, txlen, deb_data);
+
+        status = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev,0),
+                tx[0], USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0, tx, txlen,
+                USB_CTRL_GET_TIMEOUT);
+
+        if (status != txlen)
+                deb_data("ep 0 write error (status = %d, len: %d)\n",status,txlen);
+
+        return status < 0 ? status : 0;
+}
+
+/* expecting tx buffer: request data[0] ... data[n] (n <= 4) */
+int dib0700_ctrl_rd(struct dvb_usb_device *d, u8 *tx, u8 txlen, u8 *rx, u8 rxlen)
+{
+        u16 index, value;
+        int status;
+
+        if (txlen < 2) {
+                err("tx buffer length is smaller than 2. Makes no sense.");
+                return -EINVAL;
+        }
+        if (txlen > 4) {
+                err("tx buffer length is larger than 4. Not supported.");
+                return -EINVAL;
+        }
+
+        deb_data(">>> ");
+        debug_dump(tx,txlen,deb_data);
+
+        value = ((txlen - 2) << 8) | tx[1];
+        index = 0;
+        if (txlen > 2)
+                index |= (tx[2] << 8);
+        if (txlen > 3)
+                index |= tx[3];
+
+        status = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev,0), tx[0],
+                        USB_TYPE_VENDOR | USB_DIR_IN, value, index, rx, rxlen,
+                        USB_CTRL_GET_TIMEOUT);
+
+        if (status < 0)
+                deb_info("ep 0 read error (status = %d)\n",status);
+
+        deb_data("<<< ");
+        debug_dump(rx, rxlen, deb_data);
+
+        return status; /* length in case of success */
+}
+
+int dib0700_set_gpio(struct dvb_usb_device *d, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val)
+{
+        struct dib0700_state *st = d->priv;
+        int ret;
+
+        if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+                deb_info("could not acquire lock");
+                return 0;
+        }
+
+        st->buf[0] = REQUEST_SET_GPIO;
+        st->buf[1] = gpio;
+        st->buf[2] = ((gpio_dir & 0x01) << 7) | ((gpio_val & 0x01) << 6);
+
+        ret = dib0700_ctrl_wr(d, st->buf, 3);
+
+        mutex_unlock(&d->usb_mutex);
+        return ret;
+}
+
+static int dib0700_set_usb_xfer_len(struct dvb_usb_device *d, u16 nb_ts_packets)
+{
+        struct dib0700_state *st = d->priv;
+        int ret;
+
+        if (st->fw_version >= 0x10201) {
+                if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+                        deb_info("could not acquire lock");
+                        return 0;
+                }
+
+                st->buf[0] = REQUEST_SET_USB_XFER_LEN;
+                st->buf[1] = (nb_ts_packets >> 8) & 0xff;
+                st->buf[2] = nb_ts_packets & 0xff;
+
+                deb_info("set the USB xfer len to %i Ts packet\n", nb_ts_packets);
+
+                ret = dib0700_ctrl_wr(d, st->buf, 3);
+                mutex_unlock(&d->usb_mutex);
+        } else {
+                deb_info("this firmware does not allow to change the USB xfer len\n");
+                ret = -EIO;
+        }
+
+        return ret;
+}
+
+/*
+ * I2C master xfer function (supported in 1.20 firmware)
+ */
+static int dib0700_i2c_xfer_new(struct i2c_adapter *adap, struct i2c_msg *msg,
+                                int num)
+{
+        /* The new i2c firmware messages are more reliable and in particular
+           properly support i2c read calls not preceded by a write */
+
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        struct dib0700_state *st = d->priv;
+        uint8_t bus_mode = 1;  /* 0=eeprom bus, 1=frontend bus */
+        uint8_t gen_mode = 0; /* 0=master i2c, 1=gpio i2c */
+        uint8_t en_start = 0;
+        uint8_t en_stop = 0;
+        int result, i;
+
+        /* Ensure nobody else hits the i2c bus while we're sending our
+           sequence of messages, (such as the remote control thread) */
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                if (i == 0) {
+                        /* First message in the transaction */
+                        en_start = 1;
+                } else if (!(msg[i].flags & I2C_M_NOSTART)) {
+                        /* Device supports repeated-start */
+                        en_start = 1;
+                } else {
+                        /* Not the first packet and device doesn't support
+                           repeated start */
+                        en_start = 0;
+                }
+                if (i == (num - 1)) {
+                        /* Last message in the transaction */
+                        en_stop = 1;
+                }
+
+                if (msg[i].flags & I2C_M_RD) {
+                        /* Read request */
+                        u16 index, value;
+                        uint8_t i2c_dest;
+
+                        i2c_dest = (msg[i].addr << 1);
+                        value = ((en_start << 7) | (en_stop << 6) |
+                                 (msg[i].len & 0x3F)) << 8 | i2c_dest;
+                        /* I2C ctrl + FE bus; */
+                        index = ((gen_mode << 6) & 0xC0) |
+                                ((bus_mode << 4) & 0x30);
+
+                        result = usb_control_msg(d->udev,
+                                                 usb_rcvctrlpipe(d->udev, 0),
+                                                 REQUEST_NEW_I2C_READ,
+                                                 USB_TYPE_VENDOR | USB_DIR_IN,
+                                                 value, index, msg[i].buf,
+                                                 msg[i].len,
+                                                 USB_CTRL_GET_TIMEOUT);
+                        if (result < 0) {
+                                deb_info("i2c read error (status = %d)\n", result);
+                                break;
+                        }
+
+                        deb_data("<<< ");
+                        debug_dump(msg[i].buf, msg[i].len, deb_data);
+
+                } else {
+                        /* Write request */
+                        if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+                                deb_info("could not acquire lock");
+                                return 0;
+                        }
+                        st->buf[0] = REQUEST_NEW_I2C_WRITE;
+                        st->buf[1] = msg[i].addr << 1;
+                        st->buf[2] = (en_start << 7) | (en_stop << 6) |
+                                (msg[i].len & 0x3F);
+                        /* I2C ctrl + FE bus; */
+                        st->buf[3] = ((gen_mode << 6) & 0xC0) |
+                                 ((bus_mode << 4) & 0x30);
+                        /* The Actual i2c payload */
+                        memcpy(&st->buf[4], msg[i].buf, msg[i].len);
+
+                        deb_data(">>> ");
+                        debug_dump(st->buf, msg[i].len + 4, deb_data);
+
+                        result = usb_control_msg(d->udev,
+                                                 usb_sndctrlpipe(d->udev, 0),
+                                                 REQUEST_NEW_I2C_WRITE,
+                                                 USB_TYPE_VENDOR | USB_DIR_OUT,
+                                                 0, 0, st->buf, msg[i].len + 4,
+                                                 USB_CTRL_GET_TIMEOUT);
+                        mutex_unlock(&d->usb_mutex);
+                        if (result < 0) {
+                                deb_info("i2c write error (status = %d)\n", result);
+                                break;
+                        }
+                }
+        }
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+/*
+ * I2C master xfer function (pre-1.20 firmware)
+ */
+static int dib0700_i2c_xfer_legacy(struct i2c_adapter *adap,
+                                   struct i2c_msg *msg, int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        struct dib0700_state *st = d->priv;
+        int i,len;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+        if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+                deb_info("could not acquire lock");
+                return 0;
+        }
+
+        for (i = 0; i < num; i++) {
+                /* fill in the address */
+                st->buf[1] = msg[i].addr << 1;
+                /* fill the buffer */
+                memcpy(&st->buf[2], msg[i].buf, msg[i].len);
+
+                /* write/read request */
+                if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
+                        st->buf[0] = REQUEST_I2C_READ;
+                        st->buf[1] |= 1;
+
+                        /* special thing in the current firmware: when length is zero the read-failed */
+                        len = dib0700_ctrl_rd(d, st->buf, msg[i].len + 2,
+                                        msg[i+1].buf, msg[i+1].len);
+                        if (len <= 0) {
+                                deb_info("I2C read failed on address 0x%02x\n",
+                                                msg[i].addr);
+                                break;
+                        }
+
+                        msg[i+1].len = len;
+
+                        i++;
+                } else {
+                        st->buf[0] = REQUEST_I2C_WRITE;
+                        if (dib0700_ctrl_wr(d, st->buf, msg[i].len + 2) < 0)
+                                break;
+                }
+        }
+        mutex_unlock(&d->usb_mutex);
+        mutex_unlock(&d->i2c_mutex);
+
+        return i;
+}
+
+static int dib0700_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
+                            int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        struct dib0700_state *st = d->priv;
+
+        if (st->fw_use_new_i2c_api == 1) {
+                /* User running at least fw 1.20 */
+                return dib0700_i2c_xfer_new(adap, msg, num);
+        } else {
+                /* Use legacy calls */
+                return dib0700_i2c_xfer_legacy(adap, msg, num);
+        }
+}
+
+static u32 dib0700_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+struct i2c_algorithm dib0700_i2c_algo = {
+        .master_xfer   = dib0700_i2c_xfer,
+        .functionality = dib0700_i2c_func,
+};
+
+int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props,
+                        struct dvb_usb_device_description **desc, int *cold)
+{
+        s16 ret;
+        u8 *b;
+
+        b = kmalloc(16, GFP_KERNEL);
+        if (!b)
+                return  -ENOMEM;
+
+
+        ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                REQUEST_GET_VERSION, USB_TYPE_VENDOR | USB_DIR_IN, 0, 0, b, 16, USB_CTRL_GET_TIMEOUT);
+
+        deb_info("FW GET_VERSION length: %d\n",ret);
+
+        *cold = ret <= 0;
+        deb_info("cold: %d\n", *cold);
+
+        kfree(b);
+        return 0;
+}
+
+static int dib0700_set_clock(struct dvb_usb_device *d, u8 en_pll,
+        u8 pll_src, u8 pll_range, u8 clock_gpio3, u16 pll_prediv,
+        u16 pll_loopdiv, u16 free_div, u16 dsuScaler)
+{
+        struct dib0700_state *st = d->priv;
+        int ret;
+
+        if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+                deb_info("could not acquire lock");
+                return 0;
+        }
+
+        st->buf[0] = REQUEST_SET_CLOCK;
+        st->buf[1] = (en_pll << 7) | (pll_src << 6) |
+                (pll_range << 5) | (clock_gpio3 << 4);
+        st->buf[2] = (pll_prediv >> 8)  & 0xff; /* MSB */
+        st->buf[3] =  pll_prediv        & 0xff; /* LSB */
+        st->buf[4] = (pll_loopdiv >> 8) & 0xff; /* MSB */
+        st->buf[5] =  pll_loopdiv       & 0xff; /* LSB */
+        st->buf[6] = (free_div >> 8)    & 0xff; /* MSB */
+        st->buf[7] =  free_div          & 0xff; /* LSB */
+        st->buf[8] = (dsuScaler >> 8)   & 0xff; /* MSB */
+        st->buf[9] =  dsuScaler         & 0xff; /* LSB */
+
+        ret = dib0700_ctrl_wr(d, st->buf, 10);
+        mutex_unlock(&d->usb_mutex);
+
+        return ret;
+}
+
+int dib0700_set_i2c_speed(struct dvb_usb_device *d, u16 scl_kHz)
+{
+        struct dib0700_state *st = d->priv;
+        u16 divider;
+        int ret;
+
+        if (scl_kHz == 0)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+                deb_info("could not acquire lock");
+                return 0;
+        }
+
+        st->buf[0] = REQUEST_SET_I2C_PARAM;
+        divider = (u16) (30000 / scl_kHz);
+        st->buf[1] = 0;
+        st->buf[2] = (u8) (divider >> 8);
+        st->buf[3] = (u8) (divider & 0xff);
+        divider = (u16) (72000 / scl_kHz);
+        st->buf[4] = (u8) (divider >> 8);
+        st->buf[5] = (u8) (divider & 0xff);
+        divider = (u16) (72000 / scl_kHz); /* clock: 72MHz */
+        st->buf[6] = (u8) (divider >> 8);
+        st->buf[7] = (u8) (divider & 0xff);
+
+        deb_info("setting I2C speed: %04x %04x %04x (%d kHz).",
+                (st->buf[2] << 8) | (st->buf[3]), (st->buf[4] << 8) |
+                st->buf[5], (st->buf[6] << 8) | st->buf[7], scl_kHz);
+
+        ret = dib0700_ctrl_wr(d, st->buf, 8);
+        mutex_unlock(&d->usb_mutex);
+
+        return ret;
+}
+
+
+int dib0700_ctrl_clock(struct dvb_usb_device *d, u32 clk_MHz, u8 clock_out_gp3)
+{
+        switch (clk_MHz) {
+                case 72: dib0700_set_clock(d, 1, 0, 1, clock_out_gp3, 2, 24, 0, 0x4c); break;
+                default: return -EINVAL;
+        }
+        return 0;
+}
+
+static int dib0700_jumpram(struct usb_device *udev, u32 address)
+{
+        int ret = 0, actlen;
+        u8 *buf;
+
+        buf = kmalloc(8, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        buf[0] = REQUEST_JUMPRAM;
+        buf[1] = 0;
+        buf[2] = 0;
+        buf[3] = 0;
+        buf[4] = (address >> 24) & 0xff;
+        buf[5] = (address >> 16) & 0xff;
+        buf[6] = (address >> 8)  & 0xff;
+        buf[7] =  address        & 0xff;
+
+        if ((ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x01),buf,8,&actlen,1000)) < 0) {
+                deb_fw("jumpram to 0x%x failed\n",address);
+                goto out;
+        }
+        if (actlen != 8) {
+                deb_fw("jumpram to 0x%x failed\n",address);
+                ret = -EIO;
+                goto out;
+        }
+out:
+        kfree(buf);
+        return ret;
+}
+
+int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw)
+{
+        struct hexline hx;
+        int pos = 0, ret, act_len, i, adap_num;
+        u8 *buf;
+        u32 fw_version;
+
+        buf = kmalloc(260, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        while ((ret = dvb_usb_get_hexline(fw, &hx, &pos)) > 0) {
+                deb_fwdata("writing to address 0x%08x (buffer: 0x%02x %02x)\n",
+                                hx.addr, hx.len, hx.chk);
+
+                buf[0] = hx.len;
+                buf[1] = (hx.addr >> 8) & 0xff;
+                buf[2] =  hx.addr       & 0xff;
+                buf[3] = hx.type;
+                memcpy(&buf[4],hx.data,hx.len);
+                buf[4+hx.len] = hx.chk;
+
+                ret = usb_bulk_msg(udev,
+                        usb_sndbulkpipe(udev, 0x01),
+                        buf,
+                        hx.len + 5,
+                        &act_len,
+                        1000);
+
+                if (ret < 0) {
+                        err("firmware download failed at %d with %d",pos,ret);
+                        goto out;
+                }
+        }
+
+        if (ret == 0) {
+                /* start the firmware */
+                if ((ret = dib0700_jumpram(udev, 0x70000000)) == 0) {
+                        info("firmware started successfully.");
+                        msleep(500);
+                }
+        } else
+                ret = -EIO;
+
+        /* the number of ts packet has to be at least 1 */
+        if (nb_packet_buffer_size < 1)
+                nb_packet_buffer_size = 1;
+
+        /* get the fimware version */
+        usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                                  REQUEST_GET_VERSION,
+                                  USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
+                                  buf, 16, USB_CTRL_GET_TIMEOUT);
+        fw_version = (buf[8] << 24) | (buf[9] << 16) | (buf[10] << 8) | buf[11];
+
+        /* set the buffer size - DVB-USB is allocating URB buffers
+         * only after the firwmare download was successful */
+        for (i = 0; i < dib0700_device_count; i++) {
+                for (adap_num = 0; adap_num < dib0700_devices[i].num_adapters;
+                                adap_num++) {
+                        if (fw_version >= 0x10201) {
+                                dib0700_devices[i].adapter[adap_num].stream.u.bulk.buffersize = 188*nb_packet_buffer_size;
+                        } else {
+                                /* for fw version older than 1.20.1,
+                                 * the buffersize has to be n times 512 */
+                                dib0700_devices[i].adapter[adap_num].stream.u.bulk.buffersize = ((188*nb_packet_buffer_size+188/2)/512)*512;
+                                if (dib0700_devices[i].adapter[adap_num].stream.u.bulk.buffersize < 512)
+                                        dib0700_devices[i].adapter[adap_num].stream.u.bulk.buffersize = 512;
+                        }
+                }
+        }
+out:
+        kfree(buf);
+        return ret;
+}
+
+int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        struct dib0700_state *st = adap->dev->priv;
+        int ret;
+
+        if ((onoff != 0) && (st->fw_version >= 0x10201)) {
+                /* for firmware later than 1.20.1,
+                 * the USB xfer length can be set  */
+                ret = dib0700_set_usb_xfer_len(adap->dev,
+                        st->nb_packet_buffer_size);
+                if (ret < 0) {
+                        deb_info("can not set the USB xfer len\n");
+                        return ret;
+                }
+        }
+
+        if (mutex_lock_interruptible(&adap->dev->usb_mutex) < 0) {
+                deb_info("could not acquire lock");
+                return 0;
+        }
+
+        st->buf[0] = REQUEST_ENABLE_VIDEO;
+        /* this bit gives a kind of command,
+         * rather than enabling something or not */
+        st->buf[1] = (onoff << 4) | 0x00;
+
+        if (st->disable_streaming_master_mode == 1)
+                st->buf[2] = 0x00;
+        else
+                st->buf[2] = 0x01 << 4; /* Master mode */
+
+        st->buf[3] = 0x00;
+
+        deb_info("modifying (%d) streaming state for %d\n", onoff, adap->id);
+
+        st->channel_state &= ~0x3;
+        if ((adap->stream.props.endpoint != 2)
+                        && (adap->stream.props.endpoint != 3)) {
+                deb_info("the endpoint number (%i) is not correct, use the adapter id instead", adap->stream.props.endpoint);
+                if (onoff)
+                        st->channel_state |=    1 << (adap->id);
+                else
+                        st->channel_state |=    1 << ~(adap->id);
+        } else {
+                if (onoff)
+                        st->channel_state |=    1 << (adap->stream.props.endpoint-2);
+                else
+                        st->channel_state |=    1 << (3-adap->stream.props.endpoint);
+        }
+
+        st->buf[2] |= st->channel_state;
+
+        deb_info("data for streaming: %x %x\n", st->buf[1], st->buf[2]);
+
+        ret = dib0700_ctrl_wr(adap->dev, st->buf, 4);
+        mutex_unlock(&adap->dev->usb_mutex);
+
+        return ret;
+}
+
+int dib0700_change_protocol(struct rc_dev *rc, u64 rc_type)
+{
+        struct dvb_usb_device *d = rc->priv;
+        struct dib0700_state *st = d->priv;
+        int new_proto, ret;
+
+        if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+                deb_info("could not acquire lock");
+                return 0;
+        }
+
+        st->buf[0] = REQUEST_SET_RC;
+        st->buf[1] = 0;
+        st->buf[2] = 0;
+
+        /* Set the IR mode */
+        if (rc_type == RC_TYPE_RC5)
+                new_proto = 1;
+        else if (rc_type == RC_TYPE_NEC)
+                new_proto = 0;
+        else if (rc_type == RC_TYPE_RC6) {
+                if (st->fw_version < 0x10200) {
+                        ret = -EINVAL;
+                        goto out;
+                }
+
+                new_proto = 2;
+        } else {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        st->buf[1] = new_proto;
+
+        ret = dib0700_ctrl_wr(d, st->buf, 3);
+        if (ret < 0) {
+                err("ir protocol setup failed");
+                goto out;
+        }
+
+        d->props.rc.core.protocol = rc_type;
+
+out:
+        mutex_unlock(&d->usb_mutex);
+        return ret;
+}
+
+/* Number of keypresses to ignore before start repeating */
+#define RC_REPEAT_DELAY_V1_20 10
+
+/* This is the structure of the RC response packet starting in firmware 1.20 */
+struct dib0700_rc_response {
+        u8 report_id;
+        u8 data_state;
+        union {
+                u16 system16;
+                struct {
+                        u8 not_system;
+                        u8 system;
+                };
+        };
+        u8 data;
+        u8 not_data;
+};
+#define RC_MSG_SIZE_V1_20 6
+
+static void dib0700_rc_urb_completion(struct urb *purb)
+{
+        struct dvb_usb_device *d = purb->context;
+        struct dib0700_rc_response *poll_reply;
+        u32 uninitialized_var(keycode);
+        u8 toggle;
+
+        deb_info("%s()\n", __func__);
+        if (d == NULL)
+                return;
+
+        if (d->rc_dev == NULL) {
+                /* This will occur if disable_rc_polling=1 */
+                usb_free_urb(purb);
+                return;
+        }
+
+        poll_reply = purb->transfer_buffer;
+
+        if (purb->status < 0) {
+                deb_info("discontinuing polling\n");
+                usb_free_urb(purb);
+                return;
+        }
+
+        if (purb->actual_length != RC_MSG_SIZE_V1_20) {
+                deb_info("malformed rc msg size=%d\n", purb->actual_length);
+                goto resubmit;
+        }
+
+        deb_data("IR ID = %02X state = %02X System = %02X %02X Cmd = %02X %02X (len %d)\n",
+                 poll_reply->report_id, poll_reply->data_state,
+                 poll_reply->system, poll_reply->not_system,
+                 poll_reply->data, poll_reply->not_data,
+                 purb->actual_length);
+
+        switch (d->props.rc.core.protocol) {
+        case RC_TYPE_NEC:
+                toggle = 0;
+
+                /* NEC protocol sends repeat code as 0 0 0 FF */
+                if ((poll_reply->system == 0x00) && (poll_reply->data == 0x00)
+                    && (poll_reply->not_data == 0xff)) {
+                        poll_reply->data_state = 2;
+                        break;
+                }
+
+                if ((poll_reply->system ^ poll_reply->not_system) != 0xff) {
+                        deb_data("NEC extended protocol\n");
+                        /* NEC extended code - 24 bits */
+                        keycode = be16_to_cpu(poll_reply->system16) << 8 | poll_reply->data;
+                } else {
+                        deb_data("NEC normal protocol\n");
+                        /* normal NEC code - 16 bits */
+                        keycode = poll_reply->system << 8 | poll_reply->data;
+                }
+
+                break;
+        default:
+                deb_data("RC5 protocol\n");
+                /* RC5 Protocol */
+                toggle = poll_reply->report_id;
+                keycode = poll_reply->system << 8 | poll_reply->data;
+
+                break;
+        }
+
+        if ((poll_reply->data + poll_reply->not_data) != 0xff) {
+                /* Key failed integrity check */
+                err("key failed integrity check: %04x %02x %02x",
+                    poll_reply->system,
+                    poll_reply->data, poll_reply->not_data);
+                goto resubmit;
+        }
+
+        rc_keydown(d->rc_dev, keycode, toggle);
+
+resubmit:
+        /* Clean the buffer before we requeue */
+        memset(purb->transfer_buffer, 0, RC_MSG_SIZE_V1_20);
+
+        /* Requeue URB */
+        usb_submit_urb(purb, GFP_ATOMIC);
+}
+
+int dib0700_rc_setup(struct dvb_usb_device *d)
+{
+        struct dib0700_state *st = d->priv;
+        struct urb *purb;
+        int ret;
+
+        /* Poll-based. Don't initialize bulk mode */
+        if (st->fw_version < 0x10200)
+                return 0;
+
+        /* Starting in firmware 1.20, the RC info is provided on a bulk pipe */
+        purb = usb_alloc_urb(0, GFP_KERNEL);
+        if (purb == NULL) {
+                err("rc usb alloc urb failed\n");
+                return -ENOMEM;
+        }
+
+        purb->transfer_buffer = kzalloc(RC_MSG_SIZE_V1_20, GFP_KERNEL);
+        if (purb->transfer_buffer == NULL) {
+                err("rc kzalloc failed\n");
+                usb_free_urb(purb);
+                return -ENOMEM;
+        }
+
+        purb->status = -EINPROGRESS;
+        usb_fill_bulk_urb(purb, d->udev, usb_rcvbulkpipe(d->udev, 1),
+                          purb->transfer_buffer, RC_MSG_SIZE_V1_20,
+                          dib0700_rc_urb_completion, d);
+
+        ret = usb_submit_urb(purb, GFP_ATOMIC);
+        if (ret)
+                err("rc submit urb failed\n");
+
+        return ret;
+}
+
+static int dib0700_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        int i;
+        struct dvb_usb_device *dev;
+
+        for (i = 0; i < dib0700_device_count; i++)
+                if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE,
+                    &dev, adapter_nr) == 0) {
+                        struct dib0700_state *st = dev->priv;
+                        u32 hwversion, romversion, fw_version, fwtype;
+
+                        dib0700_get_version(dev, &hwversion, &romversion,
+                                &fw_version, &fwtype);
+
+                        deb_info("Firmware version: %x, %d, 0x%x, %d\n",
+                                hwversion, romversion, fw_version, fwtype);
+
+                        st->fw_version = fw_version;
+                        st->nb_packet_buffer_size = (u32)nb_packet_buffer_size;
+
+                        /* Disable polling mode on newer firmwares */
+                        if (st->fw_version >= 0x10200)
+                                dev->props.rc.core.bulk_mode = true;
+                        else
+                                dev->props.rc.core.bulk_mode = false;
+
+                        dib0700_rc_setup(dev);
+
+                        return 0;
+                }
+
+        return -ENODEV;
+}
+
+static struct usb_driver dib0700_driver = {
+        .name       = "dvb_usb_dib0700",
+        .probe      = dib0700_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table   = dib0700_usb_id_table,
+};
+
+/* module stuff */
+static int __init dib0700_module_init(void)
+{
+        int result;
+        info("loaded with support for %d different device-types", dib0700_device_count);
+        if ((result = usb_register(&dib0700_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit dib0700_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&dib0700_driver);
+}
+
+module_init (dib0700_module_init);
+module_exit (dib0700_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <pboettcher@dibcom.fr>");
+MODULE_DESCRIPTION("Driver for devices based on DiBcom DiB0700 - USB bridge");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/dib0700_devices.c b/drivers/media/dvb/dvb-usb/dib0700_devices.c
new file mode 100644
index 00000000000..d0ea5b64f6b
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dib0700_devices.c
@@ -0,0 +1,3966 @@
+/* Linux driver for devices based on the DiBcom DiB0700 USB bridge
+ *
+ *      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, version 2.
+ *
+ *  Copyright (C) 2005-9 DiBcom, SA et al
+ */
+#include "dib0700.h"
+
+#include "dib3000mc.h"
+#include "dib7000m.h"
+#include "dib7000p.h"
+#include "dib8000.h"
+#include "dib9000.h"
+#include "mt2060.h"
+#include "mt2266.h"
+#include "tuner-xc2028.h"
+#include "xc5000.h"
+#include "xc4000.h"
+#include "s5h1411.h"
+#include "dib0070.h"
+#include "dib0090.h"
+#include "lgdt3305.h"
+#include "mxl5007t.h"
+
+static int force_lna_activation;
+module_param(force_lna_activation, int, 0644);
+MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), "
+                "if applicable for the device (default: 0=automatic/off).");
+
+struct dib0700_adapter_state {
+        int (*set_param_save) (struct dvb_frontend *, struct dvb_frontend_parameters *);
+        const struct firmware *frontend_firmware;
+};
+
+/* Hauppauge Nova-T 500 (aka Bristol)
+ *  has a LNA on GPIO0 which is enabled by setting 1 */
+static struct mt2060_config bristol_mt2060_config[2] = {
+        {
+                .i2c_address = 0x60,
+                .clock_out   = 3,
+        }, {
+                .i2c_address = 0x61,
+        }
+};
+
+
+static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = {
+        .band_caps = BAND_VHF | BAND_UHF,
+        .setup     = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0),
+
+        .agc1_max = 42598,
+        .agc1_min = 17694,
+        .agc2_max = 45875,
+        .agc2_min = 0,
+
+        .agc1_pt1 = 0,
+        .agc1_pt2 = 59,
+
+        .agc1_slope1 = 0,
+        .agc1_slope2 = 69,
+
+        .agc2_pt1 = 0,
+        .agc2_pt2 = 59,
+
+        .agc2_slope1 = 111,
+        .agc2_slope2 = 28,
+};
+
+static struct dib3000mc_config bristol_dib3000mc_config[2] = {
+        {       .agc          = &bristol_dib3000p_mt2060_agc_config,
+                .max_time     = 0x196,
+                .ln_adc_level = 0x1cc7,
+                .output_mpeg2_in_188_bytes = 1,
+        },
+        {       .agc          = &bristol_dib3000p_mt2060_agc_config,
+                .max_time     = 0x196,
+                .ln_adc_level = 0x1cc7,
+                .output_mpeg2_in_188_bytes = 1,
+        }
+};
+
+static int bristol_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_state *st = adap->dev->priv;
+        if (adap->id == 0) {
+                dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10);
+
+                if (force_lna_activation)
+                        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+                else
+                        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
+
+                if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) {
+                        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10);
+                        return -ENODEV;
+                }
+        }
+        st->mt2060_if1[adap->id] = 1220;
+        return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap,
+                (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0;
+}
+
+static int eeprom_read(struct i2c_adapter *adap,u8 adrs,u8 *pval)
+{
+        struct i2c_msg msg[2] = {
+                { .addr = 0x50, .flags = 0,        .buf = &adrs, .len = 1 },
+                { .addr = 0x50, .flags = I2C_M_RD, .buf = pval,  .len = 1 },
+        };
+        if (i2c_transfer(adap, msg, 2) != 2) return -EREMOTEIO;
+        return 0;
+}
+
+static int bristol_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
+        struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
+        s8 a;
+        int if1=1220;
+        if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
+                adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_500_2)) {
+                if (!eeprom_read(prim_i2c,0x59 + adap->id,&a)) if1=1220+a;
+        }
+        return dvb_attach(mt2060_attach,adap->fe, tun_i2c,&bristol_mt2060_config[adap->id],
+                if1) == NULL ? -ENODEV : 0;
+}
+
+/* STK7700D: Pinnacle/Terratec/Hauppauge Dual DVB-T Diversity */
+
+/* MT226x */
+static struct dibx000_agc_config stk7700d_7000p_mt2266_agc_config[2] = {
+        {
+                BAND_UHF,
+
+                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
+                * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
+                (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
+            | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
+
+                1130,
+                21,
+
+                0,
+                118,
+
+                0,
+                3530,
+                1,
+                0,
+
+                65535,
+                33770,
+                65535,
+                23592,
+
+                0,
+                62,
+                255,
+                64,
+                64,
+                132,
+                192,
+                80,
+                80,
+
+                17,
+                27,
+                23,
+                51,
+
+                1,
+        }, {
+                BAND_VHF | BAND_LBAND,
+
+                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=1, P_agc_inv_pwm2=1,
+                * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
+                (0 << 15) | (0 << 14) | (1 << 11) | (1 << 10) | (1 << 9) | (0 << 8)
+            | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
+
+                2372,
+                21,
+
+                0,
+                118,
+
+                0,
+                3530,
+                1,
+                0,
+
+                65535,
+                0,
+                65535,
+                23592,
+
+                0,
+                128,
+                128,
+                128,
+                0,
+                128,
+                253,
+                81,
+                0,
+
+                17,
+                27,
+                23,
+                51,
+
+                1,
+        }
+};
+
+static struct dibx000_bandwidth_config stk7700d_mt2266_pll_config = {
+        60000, 30000,
+        1, 8, 3, 1, 0,
+        0, 0, 1, 1, 2,
+        (3 << 14) | (1 << 12) | (524 << 0),
+        0,
+        20452225,
+};
+
+static struct dib7000p_config stk7700d_dib7000p_mt2266_config[] = {
+        {       .output_mpeg2_in_188_bytes = 1,
+                .hostbus_diversity = 1,
+                .tuner_is_baseband = 1,
+
+                .agc_config_count = 2,
+                .agc = stk7700d_7000p_mt2266_agc_config,
+                .bw  = &stk7700d_mt2266_pll_config,
+
+                .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+        },
+        {       .output_mpeg2_in_188_bytes = 1,
+                .hostbus_diversity = 1,
+                .tuner_is_baseband = 1,
+
+                .agc_config_count = 2,
+                .agc = stk7700d_7000p_mt2266_agc_config,
+                .bw  = &stk7700d_mt2266_pll_config,
+
+                .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+        }
+};
+
+static struct mt2266_config stk7700d_mt2266_config[2] = {
+        {       .i2c_address = 0x60
+        },
+        {       .i2c_address = 0x60
+        }
+};
+
+static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (adap->id == 0) {
+                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+                msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+                dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+                dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+                msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+                msleep(10);
+                if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                                             stk7700d_dib7000p_mt2266_config)
+                    != 0) {
+                        err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+                        return -ENODEV;
+                }
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
+                                &stk7700d_dib7000p_mt2266_config[adap->id]);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (adap->id == 0) {
+                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+                msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+                dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+                dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+                msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+                msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+                if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
+                                             stk7700d_dib7000p_mt2266_config)
+                    != 0) {
+                        err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+                        return -ENODEV;
+                }
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap,0x80+(adap->id << 1),
+                                &stk7700d_dib7000p_mt2266_config[adap->id]);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int stk7700d_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct i2c_adapter *tun_i2c;
+        tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+        return dvb_attach(mt2266_attach, adap->fe, tun_i2c,
+                &stk7700d_mt2266_config[adap->id]) == NULL ? -ENODEV : 0;
+}
+
+/* STK7700-PH: Digital/Analog Hybrid Tuner, e.h. Cinergy HT USB HE */
+static struct dibx000_agc_config xc3028_agc_config = {
+        BAND_VHF | BAND_UHF,       /* band_caps */
+
+        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=0,
+         * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
+         * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
+        (0 << 15) | (0 << 14) | (0 << 11) | (0 << 10) | (0 << 9) | (0 << 8) |
+        (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0), /* setup */
+
+        712,    /* inv_gain */
+        21,     /* time_stabiliz */
+
+        0,      /* alpha_level */
+        118,    /* thlock */
+
+        0,      /* wbd_inv */
+        2867,   /* wbd_ref */
+        0,      /* wbd_sel */
+        2,      /* wbd_alpha */
+
+        0,      /* agc1_max */
+        0,      /* agc1_min */
+        39718,  /* agc2_max */
+        9930,   /* agc2_min */
+        0,      /* agc1_pt1 */
+        0,      /* agc1_pt2 */
+        0,      /* agc1_pt3 */
+        0,      /* agc1_slope1 */
+        0,      /* agc1_slope2 */
+        0,      /* agc2_pt1 */
+        128,    /* agc2_pt2 */
+        29,     /* agc2_slope1 */
+        29,     /* agc2_slope2 */
+
+        17,     /* alpha_mant */
+        27,     /* alpha_exp */
+        23,     /* beta_mant */
+        51,     /* beta_exp */
+
+        1,      /* perform_agc_softsplit */
+};
+
+/* PLL Configuration for COFDM BW_MHz = 8.00 with external clock = 30.00 */
+static struct dibx000_bandwidth_config xc3028_bw_config = {
+        60000, 30000, /* internal, sampling */
+        1, 8, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass */
+        0, 0, 1, 1, 0, /* misc: refdiv, bypclk_div, IO_CLK_en_core, ADClkSrc,
+                          modulo */
+        (3 << 14) | (1 << 12) | (524 << 0), /* sad_cfg: refsel, sel, freq_15k */
+        (1 << 25) | 5816102, /* ifreq = 5.200000 MHz */
+        20452225, /* timf */
+        30000000, /* xtal_hz */
+};
+
+static struct dib7000p_config stk7700ph_dib7700_xc3028_config = {
+        .output_mpeg2_in_188_bytes = 1,
+        .tuner_is_baseband = 1,
+
+        .agc_config_count = 1,
+        .agc = &xc3028_agc_config,
+        .bw  = &xc3028_bw_config,
+
+        .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+};
+
+static int stk7700ph_xc3028_callback(void *ptr, int component,
+                                     int command, int arg)
+{
+        struct dvb_usb_adapter *adap = ptr;
+
+        switch (command) {
+        case XC2028_TUNER_RESET:
+                /* Send the tuner in then out of reset */
+                dib7000p_set_gpio(adap->fe, 8, 0, 0); msleep(10);
+                dib7000p_set_gpio(adap->fe, 8, 0, 1);
+                break;
+        case XC2028_RESET_CLK:
+                break;
+        default:
+                err("%s: unknown command %d, arg %d\n", __func__,
+                        command, arg);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static struct xc2028_ctrl stk7700ph_xc3028_ctrl = {
+        .fname = XC2028_DEFAULT_FIRMWARE,
+        .max_len = 64,
+        .demod = XC3028_FE_DIBCOM52,
+};
+
+static struct xc2028_config stk7700ph_xc3028_config = {
+        .i2c_addr = 0x61,
+        .ctrl = &stk7700ph_xc3028_ctrl,
+};
+
+static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct usb_device_descriptor *desc = &adap->dev->udev->descriptor;
+
+        if (desc->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
+            desc->idProduct == cpu_to_le16(USB_PID_PINNACLE_EXPRESSCARD_320CX))
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        else
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+        msleep(10);
+
+        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                                     &stk7700ph_dib7700_xc3028_config) != 0) {
+                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                    __func__);
+                return -ENODEV;
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+                &stk7700ph_dib7700_xc3028_config);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int stk7700ph_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct i2c_adapter *tun_i2c;
+
+        tun_i2c = dib7000p_get_i2c_master(adap->fe,
+                DIBX000_I2C_INTERFACE_TUNER, 1);
+
+        stk7700ph_xc3028_config.i2c_adap = tun_i2c;
+
+        /* FIXME: generalize & move to common area */
+        adap->fe->callback = stk7700ph_xc3028_callback;
+
+        return dvb_attach(xc2028_attach, adap->fe, &stk7700ph_xc3028_config)
+                == NULL ? -ENODEV : 0;
+}
+
+#define DEFAULT_RC_INTERVAL 50
+
+static u8 rc_request[] = { REQUEST_POLL_RC, 0 };
+
+/* Number of keypresses to ignore before start repeating */
+#define RC_REPEAT_DELAY 6
+
+/*
+ * This function is used only when firmware is < 1.20 version. Newer
+ * firmwares use bulk mode, with functions implemented at dib0700_core,
+ * at dib0700_rc_urb_completion()
+ */
+static int dib0700_rc_query_old_firmware(struct dvb_usb_device *d)
+{
+        u8 key[4];
+        u32 keycode;
+        u8 toggle;
+        int i;
+        struct dib0700_state *st = d->priv;
+
+        if (st->fw_version >= 0x10200) {
+                /* For 1.20 firmware , We need to keep the RC polling
+                   callback so we can reuse the input device setup in
+                   dvb-usb-remote.c.  However, the actual work is being done
+                   in the bulk URB completion handler. */
+                return 0;
+        }
+
+        i = dib0700_ctrl_rd(d, rc_request, 2, key, 4);
+        if (i <= 0) {
+                err("RC Query Failed");
+                return -1;
+        }
+
+        /* losing half of KEY_0 events from Philipps rc5 remotes.. */
+        if (key[0] == 0 && key[1] == 0 && key[2] == 0 && key[3] == 0)
+                return 0;
+
+        /* info("%d: %2X %2X %2X %2X",dvb_usb_dib0700_ir_proto,(int)key[3-2],(int)key[3-3],(int)key[3-1],(int)key[3]);  */
+
+        dib0700_rc_setup(d); /* reset ir sensor data to prevent false events */
+
+        d->last_event = 0;
+        switch (d->props.rc.core.protocol) {
+        case RC_TYPE_NEC:
+                /* NEC protocol sends repeat code as 0 0 0 FF */
+                if ((key[3-2] == 0x00) && (key[3-3] == 0x00) &&
+                    (key[3] == 0xff))
+                        keycode = d->last_event;
+                else {
+                        keycode = key[3-2] << 8 | key[3-3];
+                        d->last_event = keycode;
+                }
+
+                rc_keydown(d->rc_dev, keycode, 0);
+                break;
+        default:
+                /* RC-5 protocol changes toggle bit on new keypress */
+                keycode = key[3-2] << 8 | key[3-3];
+                toggle = key[3-1];
+                rc_keydown(d->rc_dev, keycode, toggle);
+
+                break;
+        }
+        return 0;
+}
+
+/* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */
+static struct dibx000_agc_config stk7700p_7000m_mt2060_agc_config = {
+        BAND_UHF | BAND_VHF,
+
+        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
+         * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
+        (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
+        | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
+
+        712,
+        41,
+
+        0,
+        118,
+
+        0,
+        4095,
+        0,
+        0,
+
+        42598,
+        17694,
+        45875,
+        2621,
+        0,
+        76,
+        139,
+        52,
+        59,
+        107,
+        172,
+        57,
+        70,
+
+        21,
+        25,
+        28,
+        48,
+
+        1,
+        {  0,
+           107,
+           51800,
+           24700
+        },
+};
+
+static struct dibx000_agc_config stk7700p_7000p_mt2060_agc_config = {
+        BAND_UHF | BAND_VHF,
+
+        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
+         * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=2, P_agc_write=0 */
+        (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
+        | (3 << 5) | (0 << 4) | (2 << 1) | (0 << 0),
+
+        712,
+        41,
+
+        0,
+        118,
+
+        0,
+        4095,
+        0,
+        0,
+
+        42598,
+        16384,
+        42598,
+            0,
+
+          0,
+        137,
+        255,
+
+          0,
+        255,
+
+        0,
+        0,
+
+         0,
+        41,
+
+        15,
+        25,
+
+        28,
+        48,
+
+        0,
+};
+
+static struct dibx000_bandwidth_config stk7700p_pll_config = {
+        60000, 30000,
+        1, 8, 3, 1, 0,
+        0, 0, 1, 1, 0,
+        (3 << 14) | (1 << 12) | (524 << 0),
+        60258167,
+        20452225,
+        30000000,
+};
+
+static struct dib7000m_config stk7700p_dib7000m_config = {
+        .dvbt_mode = 1,
+        .output_mpeg2_in_188_bytes = 1,
+        .quartz_direct = 1,
+
+        .agc_config_count = 1,
+        .agc = &stk7700p_7000m_mt2060_agc_config,
+        .bw  = &stk7700p_pll_config,
+
+        .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
+};
+
+static struct dib7000p_config stk7700p_dib7000p_config = {
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_config_count = 1,
+        .agc = &stk7700p_7000p_mt2060_agc_config,
+        .bw  = &stk7700p_pll_config,
+
+        .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
+};
+
+static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_state *st = adap->dev->priv;
+        /* unless there is no real power management in DVB - we leave the device on GPIO6 */
+
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+        dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0); msleep(50);
+
+        dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1); msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO9,  GPIO_OUT, 1);
+
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10);
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(100);
+
+        dib0700_set_gpio(adap->dev,  GPIO0, GPIO_OUT, 1);
+
+        st->mt2060_if1[0] = 1220;
+
+        if (dib7000pc_detection(&adap->dev->i2c_adap)) {
+                adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000p_config);
+                st->is_dib7000pc = 1;
+        } else
+                adap->fe = dvb_attach(dib7000m_attach, &adap->dev->i2c_adap, 18, &stk7700p_dib7000m_config);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static struct mt2060_config stk7700p_mt2060_config = {
+        0x60
+};
+
+static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct i2c_adapter *prim_i2c = &adap->dev->i2c_adap;
+        struct dib0700_state *st = adap->dev->priv;
+        struct i2c_adapter *tun_i2c;
+        s8 a;
+        int if1=1220;
+        if (adap->dev->udev->descriptor.idVendor  == cpu_to_le16(USB_VID_HAUPPAUGE) &&
+                adap->dev->udev->descriptor.idProduct == cpu_to_le16(USB_PID_HAUPPAUGE_NOVA_T_STICK)) {
+                if (!eeprom_read(prim_i2c,0x58,&a)) if1=1220+a;
+        }
+        if (st->is_dib7000pc)
+                tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+        else
+                tun_i2c = dib7000m_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+
+        return dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk7700p_mt2060_config,
+                if1) == NULL ? -ENODEV : 0;
+}
+
+/* DIB7070 generic */
+static struct dibx000_agc_config dib7070_agc_config = {
+        BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
+        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
+         * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
+        (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
+        | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
+
+        600,
+        10,
+
+        0,
+        118,
+
+        0,
+        3530,
+        1,
+        5,
+
+        65535,
+                0,
+
+        65535,
+        0,
+
+        0,
+        40,
+        183,
+        206,
+        255,
+        72,
+        152,
+        88,
+        90,
+
+        17,
+        27,
+        23,
+        51,
+
+        0,
+};
+
+static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
+{
+        deb_info("reset: %d", onoff);
+        return dib7000p_set_gpio(fe, 8, 0, !onoff);
+}
+
+static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
+{
+        deb_info("sleep: %d", onoff);
+        return dib7000p_set_gpio(fe, 9, 0, onoff);
+}
+
+static struct dib0070_config dib7070p_dib0070_config[2] = {
+        {
+                .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+                .reset = dib7070_tuner_reset,
+                .sleep = dib7070_tuner_sleep,
+                .clock_khz = 12000,
+                .clock_pad_drive = 4,
+                .charge_pump = 2,
+        }, {
+                .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+                .reset = dib7070_tuner_reset,
+                .sleep = dib7070_tuner_sleep,
+                .clock_khz = 12000,
+                .charge_pump = 2,
+        }
+};
+
+static struct dib0070_config dib7770p_dib0070_config = {
+         .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+         .reset = dib7070_tuner_reset,
+         .sleep = dib7070_tuner_sleep,
+         .clock_khz = 12000,
+         .clock_pad_drive = 0,
+         .flip_chip = 1,
+         .charge_pump = 2,
+};
+
+static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        u16 offset;
+        u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
+        switch (band) {
+                case BAND_VHF: offset = 950; break;
+                case BAND_UHF:
+                default: offset = 550; break;
+        }
+        deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
+        dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
+        return state->set_param_save(fe, fep);
+}
+
+static int dib7770_set_param_override(struct dvb_frontend *fe,
+                struct dvb_frontend_parameters *fep)
+{
+         struct dvb_usb_adapter *adap = fe->dvb->priv;
+         struct dib0700_adapter_state *state = adap->priv;
+
+         u16 offset;
+         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
+         switch (band) {
+         case BAND_VHF:
+                  dib7000p_set_gpio(fe, 0, 0, 1);
+                  offset = 850;
+                  break;
+         case BAND_UHF:
+         default:
+                  dib7000p_set_gpio(fe, 0, 0, 0);
+                  offset = 250;
+                  break;
+         }
+         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
+         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
+         return state->set_param_save(fe, fep);
+}
+
+static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
+{
+         struct dib0700_adapter_state *st = adap->priv;
+         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
+                         DIBX000_I2C_INTERFACE_TUNER, 1);
+
+         if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
+                                 &dib7770p_dib0070_config) == NULL)
+                 return -ENODEV;
+
+         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+         adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
+         return 0;
+}
+
+static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+
+        if (adap->id == 0) {
+                if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[0]) == NULL)
+                        return -ENODEV;
+        } else {
+                if (dvb_attach(dib0070_attach, adap->fe, tun_i2c, &dib7070p_dib0070_config[1]) == NULL)
+                        return -ENODEV;
+        }
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
+        return 0;
+}
+
+static int stk7700p_pid_filter(struct dvb_usb_adapter *adapter, int index,
+                u16 pid, int onoff)
+{
+        struct dib0700_state *st = adapter->dev->priv;
+        if (st->is_dib7000pc)
+                return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
+        return dib7000m_pid_filter(adapter->fe, index, pid, onoff);
+}
+
+static int stk7700p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
+{
+        struct dib0700_state *st = adapter->dev->priv;
+        if (st->is_dib7000pc)
+                return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
+        return dib7000m_pid_filter_ctrl(adapter->fe, onoff);
+}
+
+static int stk70x0p_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
+{
+    return dib7000p_pid_filter(adapter->fe, index, pid, onoff);
+}
+
+static int stk70x0p_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
+{
+    return dib7000p_pid_filter_ctrl(adapter->fe, onoff);
+}
+
+static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
+        60000, 15000,
+        1, 20, 3, 1, 0,
+        0, 0, 1, 1, 2,
+        (3 << 14) | (1 << 12) | (524 << 0),
+        (0 << 25) | 0,
+        20452225,
+        12000000,
+};
+
+static struct dib7000p_config dib7070p_dib7000p_config = {
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_config_count = 1,
+        .agc = &dib7070_agc_config,
+        .bw  = &dib7070_bw_config_12_mhz,
+        .tuner_is_baseband = 1,
+        .spur_protect = 1,
+
+        .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+
+        .hostbus_diversity = 1,
+};
+
+/* STK7070P */
+static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
+        if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
+            p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
+                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        else
+                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                                     &dib7070p_dib7000p_config) != 0) {
+                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                    __func__);
+                return -ENODEV;
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+                &dib7070p_dib7000p_config);
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+/* STK7770P */
+static struct dib7000p_config dib7770p_dib7000p_config = {
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_config_count = 1,
+        .agc = &dib7070_agc_config,
+        .bw  = &dib7070_bw_config_12_mhz,
+        .tuner_is_baseband = 1,
+        .spur_protect = 1,
+
+        .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+
+        .hostbus_diversity = 1,
+        .enable_current_mirror = 1,
+        .disable_sample_and_hold = 0,
+};
+
+static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct usb_device_descriptor *p = &adap->dev->udev->descriptor;
+        if (p->idVendor  == cpu_to_le16(USB_VID_PINNACLE) &&
+            p->idProduct == cpu_to_le16(USB_PID_PINNACLE_PCTV72E))
+                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        else
+                dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                                     &dib7770p_dib7000p_config) != 0) {
+                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                    __func__);
+                return -ENODEV;
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
+                &dib7770p_dib7000p_config);
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+/* DIB807x generic */
+static struct dibx000_agc_config dib807x_agc_config[2] = {
+        {
+                BAND_VHF,
+                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
+                 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
+                 * P_agc_inv_pwm2=0,P_agc_inh_dc_rv_est=0,
+                 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
+                 * P_agc_write=0 */
+                (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
+                        (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
+                        (0 << 0), /* setup*/
+
+                600, /* inv_gain*/
+                10,  /* time_stabiliz*/
+
+                0,  /* alpha_level*/
+                118,  /* thlock*/
+
+                0,     /* wbd_inv*/
+                3530,  /* wbd_ref*/
+                1,     /* wbd_sel*/
+                5,     /* wbd_alpha*/
+
+                65535,  /* agc1_max*/
+                0,  /* agc1_min*/
+
+                65535,  /* agc2_max*/
+                0,      /* agc2_min*/
+
+                0,      /* agc1_pt1*/
+                40,     /* agc1_pt2*/
+                183,    /* agc1_pt3*/
+                206,    /* agc1_slope1*/
+                255,    /* agc1_slope2*/
+                72,     /* agc2_pt1*/
+                152,    /* agc2_pt2*/
+                88,     /* agc2_slope1*/
+                90,     /* agc2_slope2*/
+
+                17,  /* alpha_mant*/
+                27,  /* alpha_exp*/
+                23,  /* beta_mant*/
+                51,  /* beta_exp*/
+
+                0,  /* perform_agc_softsplit*/
+        }, {
+                BAND_UHF,
+                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
+                 * P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0,
+                 * P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
+                 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5,
+                 * P_agc_write=0 */
+                (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
+                        (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
+                        (0 << 0), /* setup */
+
+                600, /* inv_gain*/
+                10,  /* time_stabiliz*/
+
+                0,  /* alpha_level*/
+                118,  /* thlock*/
+
+                0,     /* wbd_inv*/
+                3530,  /* wbd_ref*/
+                1,     /* wbd_sel*/
+                5,     /* wbd_alpha*/
+
+                65535,  /* agc1_max*/
+                0,  /* agc1_min*/
+
+                65535,  /* agc2_max*/
+                0,      /* agc2_min*/
+
+                0,      /* agc1_pt1*/
+                40,     /* agc1_pt2*/
+                183,    /* agc1_pt3*/
+                206,    /* agc1_slope1*/
+                255,    /* agc1_slope2*/
+                72,     /* agc2_pt1*/
+                152,    /* agc2_pt2*/
+                88,     /* agc2_slope1*/
+                90,     /* agc2_slope2*/
+
+                17,  /* alpha_mant*/
+                27,  /* alpha_exp*/
+                23,  /* beta_mant*/
+                51,  /* beta_exp*/
+
+                0,  /* perform_agc_softsplit*/
+        }
+};
+
+static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
+        60000, 15000, /* internal, sampling*/
+        1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
+        0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
+                          ADClkSrc, modulo */
+        (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
+        (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
+        18179755, /* timf*/
+        12000000, /* xtal_hz*/
+};
+
+static struct dib8000_config dib807x_dib8000_config[2] = {
+        {
+                .output_mpeg2_in_188_bytes = 1,
+
+                .agc_config_count = 2,
+                .agc = dib807x_agc_config,
+                .pll = &dib807x_bw_config_12_mhz,
+                .tuner_is_baseband = 1,
+
+                .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
+
+                .hostbus_diversity = 1,
+                .div_cfg = 1,
+                .agc_control = &dib0070_ctrl_agc_filter,
+                .output_mode = OUTMODE_MPEG2_FIFO,
+                .drives = 0x2d98,
+        }, {
+                .output_mpeg2_in_188_bytes = 1,
+
+                .agc_config_count = 2,
+                .agc = dib807x_agc_config,
+                .pll = &dib807x_bw_config_12_mhz,
+                .tuner_is_baseband = 1,
+
+                .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
+
+                .hostbus_diversity = 1,
+                .agc_control = &dib0070_ctrl_agc_filter,
+                .output_mode = OUTMODE_MPEG2_FIFO,
+                .drives = 0x2d98,
+        }
+};
+
+static int dib80xx_tuner_reset(struct dvb_frontend *fe, int onoff)
+{
+        return dib8000_set_gpio(fe, 5, 0, !onoff);
+}
+
+static int dib80xx_tuner_sleep(struct dvb_frontend *fe, int onoff)
+{
+        return dib8000_set_gpio(fe, 0, 0, onoff);
+}
+
+static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
+    { 240,      7},
+    { 0xffff,   6},
+};
+
+static struct dib0070_config dib807x_dib0070_config[2] = {
+        {
+                .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+                .reset = dib80xx_tuner_reset,
+                .sleep = dib80xx_tuner_sleep,
+                .clock_khz = 12000,
+                .clock_pad_drive = 4,
+                .vga_filter = 1,
+                .force_crystal_mode = 1,
+                .enable_third_order_filter = 1,
+                .charge_pump = 0,
+                .wbd_gain = dib8070_wbd_gain_cfg,
+                .osc_buffer_state = 0,
+                .freq_offset_khz_uhf = -100,
+                .freq_offset_khz_vhf = -100,
+        }, {
+                .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+                .reset = dib80xx_tuner_reset,
+                .sleep = dib80xx_tuner_sleep,
+                .clock_khz = 12000,
+                .clock_pad_drive = 2,
+                .vga_filter = 1,
+                .force_crystal_mode = 1,
+                .enable_third_order_filter = 1,
+                .charge_pump = 0,
+                .wbd_gain = dib8070_wbd_gain_cfg,
+                .osc_buffer_state = 0,
+                .freq_offset_khz_uhf = -25,
+                .freq_offset_khz_vhf = -25,
+        }
+};
+
+static int dib807x_set_param_override(struct dvb_frontend *fe,
+                struct dvb_frontend_parameters *fep)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        u16 offset = dib0070_wbd_offset(fe);
+        u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
+        switch (band) {
+        case BAND_VHF:
+                offset += 750;
+                break;
+        case BAND_UHF:  /* fall-thru wanted */
+        default:
+                offset += 250; break;
+        }
+        deb_info("WBD for DiB8000: %d\n", offset);
+        dib8000_set_wbd_ref(fe, offset);
+
+        return state->set_param_save(fe, fep);
+}
+
+static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
+                        DIBX000_I2C_INTERFACE_TUNER, 1);
+
+        if (adap->id == 0) {
+                if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
+                                &dib807x_dib0070_config[0]) == NULL)
+                        return -ENODEV;
+        } else {
+                if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
+                                &dib807x_dib0070_config[1]) == NULL)
+                        return -ENODEV;
+        }
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
+        return 0;
+}
+
+static int stk80xx_pid_filter(struct dvb_usb_adapter *adapter, int index,
+        u16 pid, int onoff)
+{
+        return dib8000_pid_filter(adapter->fe, index, pid, onoff);
+}
+
+static int stk80xx_pid_filter_ctrl(struct dvb_usb_adapter *adapter,
+                int onoff)
+{
+        return dib8000_pid_filter_ctrl(adapter->fe, onoff);
+}
+
+/* STK807x */
+static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                                0x80);
+
+        adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
+                              &dib807x_dib8000_config[0]);
+
+        return adap->fe == NULL ?  -ENODEV : 0;
+}
+
+/* STK807xPVR */
+static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
+{
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        msleep(30);
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(500);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        /* initialize IC 0 */
+        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x80);
+
+        adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
+                              &dib807x_dib8000_config[0]);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
+{
+        /* initialize IC 1 */
+        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x82);
+
+        adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
+                              &dib807x_dib8000_config[1]);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+/* STK8096GP */
+struct dibx000_agc_config dib8090_agc_config[2] = {
+        {
+        BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
+        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
+         * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
+         * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
+        (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
+        | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
+
+        787,
+        10,
+
+        0,
+        118,
+
+        0,
+        3530,
+        1,
+        5,
+
+        65535,
+        0,
+
+        65535,
+        0,
+
+        0,
+        32,
+        114,
+        143,
+        144,
+        114,
+        227,
+        116,
+        117,
+
+        28,
+        26,
+        31,
+        51,
+
+        0,
+        },
+        {
+        BAND_CBAND,
+        /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1,
+         * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
+         * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
+        (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8)
+        | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
+
+        787,
+        10,
+
+        0,
+        118,
+
+        0,
+        3530,
+        1,
+        5,
+
+        0,
+        0,
+
+        65535,
+        0,
+
+        0,
+        32,
+        114,
+        143,
+        144,
+        114,
+        227,
+        116,
+        117,
+
+        28,
+        26,
+        31,
+        51,
+
+        0,
+        }
+};
+
+static struct dibx000_bandwidth_config dib8090_pll_config_12mhz = {
+        54000, 13500,
+        1, 18, 3, 1, 0,
+        0, 0, 1, 1, 2,
+        (3 << 14) | (1 << 12) | (599 << 0),
+        (0 << 25) | 0,
+        20199727,
+        12000000,
+};
+
+static int dib8090_get_adc_power(struct dvb_frontend *fe)
+{
+        return dib8000_get_adc_power(fe, 1);
+}
+
+static struct dib8000_config dib809x_dib8000_config[2] = {
+        {
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_config_count = 2,
+        .agc = dib8090_agc_config,
+        .agc_control = dib0090_dcc_freq,
+        .pll = &dib8090_pll_config_12mhz,
+        .tuner_is_baseband = 1,
+
+        .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
+
+        .hostbus_diversity = 1,
+        .div_cfg = 0x31,
+        .output_mode = OUTMODE_MPEG2_FIFO,
+        .drives = 0x2d98,
+        .diversity_delay = 48,
+        .refclksel = 3,
+        }, {
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_config_count = 2,
+        .agc = dib8090_agc_config,
+        .agc_control = dib0090_dcc_freq,
+        .pll = &dib8090_pll_config_12mhz,
+        .tuner_is_baseband = 1,
+
+        .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
+
+        .hostbus_diversity = 1,
+        .div_cfg = 0x31,
+        .output_mode = OUTMODE_DIVERSITY,
+        .drives = 0x2d08,
+        .diversity_delay = 1,
+        .refclksel = 3,
+        }
+};
+
+static struct dib0090_wbd_slope dib8090_wbd_table[] = {
+        /* max freq ; cold slope ; cold offset ; warm slope ; warm offset ; wbd gain */
+        { 120,     0, 500,  0,   500, 4 }, /* CBAND */
+        { 170,     0, 450,  0,   450, 4 }, /* CBAND */
+        { 380,    48, 373, 28,   259, 6 }, /* VHF */
+        { 860,    34, 700, 36,   616, 6 }, /* high UHF */
+        { 0xFFFF, 34, 700, 36,   616, 6 }, /* default */
+};
+
+static struct dib0090_config dib809x_dib0090_config = {
+        .io.pll_bypass = 1,
+        .io.pll_range = 1,
+        .io.pll_prediv = 1,
+        .io.pll_loopdiv = 20,
+        .io.adc_clock_ratio = 8,
+        .io.pll_int_loop_filt = 0,
+        .io.clock_khz = 12000,
+        .reset = dib80xx_tuner_reset,
+        .sleep = dib80xx_tuner_sleep,
+        .clkouttobamse = 1,
+        .analog_output = 1,
+        .i2c_address = DEFAULT_DIB0090_I2C_ADDRESS,
+        .use_pwm_agc = 1,
+        .clkoutdrive = 1,
+        .get_adc_power = dib8090_get_adc_power,
+        .freq_offset_khz_uhf = -63,
+        .freq_offset_khz_vhf = -143,
+        .wbd = dib8090_wbd_table,
+        .fref_clock_ratio = 6,
+};
+
+static int dib8096_set_param_override(struct dvb_frontend *fe,
+                struct dvb_frontend_parameters *fep)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+        u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
+        u16 target;
+        int ret = 0;
+        enum frontend_tune_state tune_state = CT_SHUTDOWN;
+        u16 ltgain, rf_gain_limit;
+
+        ret = state->set_param_save(fe, fep);
+        if (ret < 0)
+                return ret;
+
+        target = (dib0090_get_wbd_offset(fe) * 8 * 18 / 33 + 1) / 2;
+        dib8000_set_wbd_ref(fe, target);
+
+
+        if (band == BAND_CBAND) {
+                deb_info("tuning in CBAND - soft-AGC startup\n");
+                dib0090_set_tune_state(fe, CT_AGC_START);
+                do {
+                        ret = dib0090_gain_control(fe);
+                        msleep(ret);
+                        tune_state = dib0090_get_tune_state(fe);
+                        if (tune_state == CT_AGC_STEP_0)
+                                dib8000_set_gpio(fe, 6, 0, 1);
+                        else if (tune_state == CT_AGC_STEP_1) {
+                                dib0090_get_current_gain(fe, NULL, NULL, &rf_gain_limit, &ltgain);
+                                if (rf_gain_limit == 0)
+                                        dib8000_set_gpio(fe, 6, 0, 0);
+                        }
+                } while (tune_state < CT_AGC_STOP);
+                dib0090_pwm_gain_reset(fe);
+                dib8000_pwm_agc_reset(fe);
+                dib8000_set_tune_state(fe, CT_DEMOD_START);
+        } else {
+                deb_info("not tuning in CBAND - standard AGC startup\n");
+                dib0090_pwm_gain_reset(fe);
+        }
+
+        return 0;
+}
+
+static int dib809x_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+
+        if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
+                return -ENODEV;
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
+        return 0;
+}
+
+static int stk809x_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 0x80);
+
+        adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
+
+        return adap->fe == NULL ?  -ENODEV : 0;
+}
+
+static int nim8096md_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c;
+        struct dvb_frontend *fe_slave  = dib8000_get_slave_frontend(adap->fe, 1);
+
+        if (fe_slave) {
+                tun_i2c = dib8000_get_i2c_master(fe_slave, DIBX000_I2C_INTERFACE_TUNER, 1);
+                if (dvb_attach(dib0090_register, fe_slave, tun_i2c, &dib809x_dib0090_config) == NULL)
+                        return -ENODEV;
+                fe_slave->dvb = adap->fe->dvb;
+                fe_slave->ops.tuner_ops.set_params = dib8096_set_param_override;
+        }
+        tun_i2c = dib8000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_TUNER, 1);
+        if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &dib809x_dib0090_config) == NULL)
+                return -ENODEV;
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib8096_set_param_override;
+
+        return 0;
+}
+
+static int nim8096md_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dvb_frontend *fe_slave;
+
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(1000);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 2, 18, 0x80);
+
+        adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80, &dib809x_dib8000_config[0]);
+        if (adap->fe == NULL)
+                return -ENODEV;
+
+        fe_slave = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82, &dib809x_dib8000_config[1]);
+        dib8000_set_slave_frontend(adap->fe, fe_slave);
+
+        return fe_slave == NULL ?  -ENODEV : 0;
+}
+
+/* STK9090M */
+static int dib90x0_pid_filter(struct dvb_usb_adapter *adapter, int index, u16 pid, int onoff)
+{
+        return dib9000_fw_pid_filter(adapter->fe, index, pid, onoff);
+}
+
+static int dib90x0_pid_filter_ctrl(struct dvb_usb_adapter *adapter, int onoff)
+{
+        return dib9000_fw_pid_filter_ctrl(adapter->fe, onoff);
+}
+
+static int dib90x0_tuner_reset(struct dvb_frontend *fe, int onoff)
+{
+        return dib9000_set_gpio(fe, 5, 0, !onoff);
+}
+
+static int dib90x0_tuner_sleep(struct dvb_frontend *fe, int onoff)
+{
+        return dib9000_set_gpio(fe, 0, 0, onoff);
+}
+
+static int dib01x0_pmu_update(struct i2c_adapter *i2c, u16 *data, u8 len)
+{
+        u8 wb[4] = { 0xc >> 8, 0xc & 0xff, 0, 0 };
+        u8 rb[2];
+        struct i2c_msg msg[2] = {
+                {.addr = 0x1e >> 1, .flags = 0, .buf = wb, .len = 2},
+                {.addr = 0x1e >> 1, .flags = I2C_M_RD, .buf = rb, .len = 2},
+        };
+        u8 index_data;
+
+        dibx000_i2c_set_speed(i2c, 250);
+
+        if (i2c_transfer(i2c, msg, 2) != 2)
+                return -EIO;
+
+        switch (rb[0] << 8 | rb[1]) {
+        case 0:
+                        deb_info("Found DiB0170 rev1: This version of DiB0170 is not supported any longer.\n");
+                        return -EIO;
+        case 1:
+                        deb_info("Found DiB0170 rev2");
+                        break;
+        case 2:
+                        deb_info("Found DiB0190 rev2");
+                        break;
+        default:
+                        deb_info("DiB01x0 not found");
+                        return -EIO;
+        }
+
+        for (index_data = 0; index_data < len; index_data += 2) {
+                wb[2] = (data[index_data + 1] >> 8) & 0xff;
+                wb[3] = (data[index_data + 1]) & 0xff;
+
+                if (data[index_data] == 0) {
+                        wb[0] = (data[index_data] >> 8) & 0xff;
+                        wb[1] = (data[index_data]) & 0xff;
+                        msg[0].len = 2;
+                        if (i2c_transfer(i2c, msg, 2) != 2)
+                                return -EIO;
+                        wb[2] |= rb[0];
+                        wb[3] |= rb[1] & ~(3 << 4);
+                }
+
+                wb[0] = (data[index_data] >> 8)&0xff;
+                wb[1] = (data[index_data])&0xff;
+                msg[0].len = 4;
+                if (i2c_transfer(i2c, &msg[0], 1) != 1)
+                        return -EIO;
+        }
+        return 0;
+}
+
+static struct dib9000_config stk9090m_config = {
+        .output_mpeg2_in_188_bytes = 1,
+        .output_mode = OUTMODE_MPEG2_FIFO,
+        .vcxo_timer = 279620,
+        .timing_frequency = 20452225,
+        .demod_clock_khz = 60000,
+        .xtal_clock_khz = 30000,
+        .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
+        .subband = {
+                2,
+                {
+                        { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0008 } }, /* GPIO 3 to 1 for VHF */
+                        { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0008, 0x0000, 0x0000 } }, /* GPIO 3 to 0 for UHF */
+                        { 0 },
+                },
+        },
+        .gpio_function = {
+                { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
+                { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
+        },
+};
+
+static struct dib9000_config nim9090md_config[2] = {
+        {
+                .output_mpeg2_in_188_bytes = 1,
+                .output_mode = OUTMODE_MPEG2_FIFO,
+                .vcxo_timer = 279620,
+                .timing_frequency = 20452225,
+                .demod_clock_khz = 60000,
+                .xtal_clock_khz = 30000,
+                .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
+        }, {
+                .output_mpeg2_in_188_bytes = 1,
+                .output_mode = OUTMODE_DIVERSITY,
+                .vcxo_timer = 279620,
+                .timing_frequency = 20452225,
+                .demod_clock_khz = 60000,
+                .xtal_clock_khz = 30000,
+                .if_drives = (0 << 15) | (1 << 13) | (0 << 12) | (3 << 10) | (0 << 9) | (1 << 7) | (0 << 6) | (0 << 4) | (1 << 3) | (1 << 1) | (0),
+                .subband = {
+                        2,
+                        {
+                                { 240, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0006 } }, /* GPIO 1 and 2 to 1 for VHF */
+                                { 890, { BOARD_GPIO_COMPONENT_DEMOD, BOARD_GPIO_FUNCTION_SUBBAND_GPIO, 0x0006, 0x0000, 0x0000 } }, /* GPIO 1 and 2 to 0 for UHF */
+                                { 0 },
+                        },
+                },
+                .gpio_function = {
+                        { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_ON, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = (0x10 & ~0x1) | 0x20 },
+                        { .component = BOARD_GPIO_COMPONENT_DEMOD, .function = BOARD_GPIO_FUNCTION_COMPONENT_OFF, .mask = 0x10 | 0x21, .direction = 0 & ~0x21, .value = 0 | 0x21 },
+                },
+        }
+};
+
+static struct dib0090_config dib9090_dib0090_config = {
+        .io.pll_bypass = 0,
+        .io.pll_range = 1,
+        .io.pll_prediv = 1,
+        .io.pll_loopdiv = 8,
+        .io.adc_clock_ratio = 8,
+        .io.pll_int_loop_filt = 0,
+        .io.clock_khz = 30000,
+        .reset = dib90x0_tuner_reset,
+        .sleep = dib90x0_tuner_sleep,
+        .clkouttobamse = 0,
+        .analog_output = 0,
+        .use_pwm_agc = 0,
+        .clkoutdrive = 0,
+        .freq_offset_khz_uhf = 0,
+        .freq_offset_khz_vhf = 0,
+};
+
+static struct dib0090_config nim9090md_dib0090_config[2] = {
+        {
+                .io.pll_bypass = 0,
+                .io.pll_range = 1,
+                .io.pll_prediv = 1,
+                .io.pll_loopdiv = 8,
+                .io.adc_clock_ratio = 8,
+                .io.pll_int_loop_filt = 0,
+                .io.clock_khz = 30000,
+                .reset = dib90x0_tuner_reset,
+                .sleep = dib90x0_tuner_sleep,
+                .clkouttobamse = 1,
+                .analog_output = 0,
+                .use_pwm_agc = 0,
+                .clkoutdrive = 0,
+                .freq_offset_khz_uhf = 0,
+                .freq_offset_khz_vhf = 0,
+        }, {
+                .io.pll_bypass = 0,
+                .io.pll_range = 1,
+                .io.pll_prediv = 1,
+                .io.pll_loopdiv = 8,
+                .io.adc_clock_ratio = 8,
+                .io.pll_int_loop_filt = 0,
+                .io.clock_khz = 30000,
+                .reset = dib90x0_tuner_reset,
+                .sleep = dib90x0_tuner_sleep,
+                .clkouttobamse = 0,
+                .analog_output = 0,
+                .use_pwm_agc = 0,
+                .clkoutdrive = 0,
+                .freq_offset_khz_uhf = 0,
+                .freq_offset_khz_vhf = 0,
+        }
+};
+
+
+static int stk9090m_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *state = adap->priv;
+        struct dib0700_state *st = adap->dev->priv;
+        u32 fw_version;
+
+        /* Make use of the new i2c functions from FW 1.20 */
+        dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
+        if (fw_version >= 0x10200)
+                st->fw_use_new_i2c_api = 1;
+        dib0700_set_i2c_speed(adap->dev, 340);
+
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
+
+        if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
+                deb_info("%s: Upload failed. (file not found?)\n", __func__);
+                return -ENODEV;
+        } else {
+                deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
+        }
+        stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
+        stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
+
+        adap->fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &stk9090m_config);
+
+        return adap->fe == NULL ?  -ENODEV : 0;
+}
+
+static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *state = adap->priv;
+        struct i2c_adapter *i2c = dib9000_get_tuner_interface(adap->fe);
+        u16 data_dib190[10] = {
+                1, 0x1374,
+                2, 0x01a2,
+                7, 0x0020,
+                0, 0x00ef,
+                8, 0x0486,
+        };
+
+        if (dvb_attach(dib0090_fw_register, adap->fe, i2c, &dib9090_dib0090_config) == NULL)
+                return -ENODEV;
+        i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
+        if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
+                return -ENODEV;
+        dib0700_set_i2c_speed(adap->dev, 2000);
+        if (dib9000_firmware_post_pll_init(adap->fe) < 0)
+                return -ENODEV;
+        release_firmware(state->frontend_firmware);
+        return 0;
+}
+
+static int nim9090md_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *state = adap->priv;
+        struct dib0700_state *st = adap->dev->priv;
+        struct i2c_adapter *i2c;
+        struct dvb_frontend *fe_slave;
+        u32 fw_version;
+
+        /* Make use of the new i2c functions from FW 1.20 */
+        dib0700_get_version(adap->dev, NULL, NULL, &fw_version, NULL);
+        if (fw_version >= 0x10200)
+                st->fw_use_new_i2c_api = 1;
+        dib0700_set_i2c_speed(adap->dev, 340);
+
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
+                deb_info("%s: Upload failed. (file not found?)\n", __func__);
+                return -EIO;
+        } else {
+                deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size);
+        }
+        nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
+        nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
+        nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
+        nim9090md_config[1].microcode_B_fe_buffer = state->frontend_firmware->data;
+
+        dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, 0x80);
+        adap->fe = dvb_attach(dib9000_attach, &adap->dev->i2c_adap, 0x80, &nim9090md_config[0]);
+
+        if (adap->fe == NULL)
+                return -ENODEV;
+
+        i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
+        dib9000_i2c_enumeration(i2c, 1, 0x12, 0x82);
+
+        fe_slave = dvb_attach(dib9000_attach, i2c, 0x82, &nim9090md_config[1]);
+        dib9000_set_slave_frontend(adap->fe, fe_slave);
+
+        return fe_slave == NULL ?  -ENODEV : 0;
+}
+
+static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *state = adap->priv;
+        struct i2c_adapter *i2c;
+        struct dvb_frontend *fe_slave;
+        u16 data_dib190[10] = {
+                1, 0x5374,
+                2, 0x01ae,
+                7, 0x0020,
+                0, 0x00ef,
+                8, 0x0406,
+        };
+        i2c = dib9000_get_tuner_interface(adap->fe);
+        if (dvb_attach(dib0090_fw_register, adap->fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
+                return -ENODEV;
+        i2c = dib9000_get_i2c_master(adap->fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
+        if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
+                return -ENODEV;
+        dib0700_set_i2c_speed(adap->dev, 2000);
+        if (dib9000_firmware_post_pll_init(adap->fe) < 0)
+                return -ENODEV;
+
+        fe_slave = dib9000_get_slave_frontend(adap->fe, 1);
+        if (fe_slave != NULL) {
+                i2c = dib9000_get_component_bus_interface(adap->fe);
+                dib9000_set_i2c_adapter(fe_slave, i2c);
+
+                i2c = dib9000_get_tuner_interface(fe_slave);
+                if (dvb_attach(dib0090_fw_register, fe_slave, i2c, &nim9090md_dib0090_config[1]) == NULL)
+                        return -ENODEV;
+                fe_slave->dvb = adap->fe->dvb;
+                dib9000_fw_set_component_bus_speed(adap->fe, 2000);
+                if (dib9000_firmware_post_pll_init(fe_slave) < 0)
+                        return -ENODEV;
+        }
+        release_firmware(state->frontend_firmware);
+
+        return 0;
+}
+
+/* NIM7090 */
+struct dib7090p_best_adc {
+        u32 timf;
+        u32 pll_loopdiv;
+        u32 pll_prediv;
+};
+
+static int dib7090p_get_best_sampling(struct dvb_frontend *fe , struct dib7090p_best_adc *adc)
+{
+        u8 spur = 0, prediv = 0, loopdiv = 0, min_prediv = 1, max_prediv = 1;
+
+        u16 xtal = 12000;
+        u32 fcp_min = 1900;  /* PLL Minimum Frequency comparator KHz */
+        u32 fcp_max = 20000; /* PLL Maximum Frequency comparator KHz */
+        u32 fdem_max = 76000;
+        u32 fdem_min = 69500;
+        u32 fcp = 0, fs = 0, fdem = 0;
+        u32 harmonic_id = 0;
+
+        adc->pll_loopdiv = loopdiv;
+        adc->pll_prediv = prediv;
+        adc->timf = 0;
+
+        deb_info("bandwidth = %d fdem_min =%d", fe->dtv_property_cache.bandwidth_hz, fdem_min);
+
+        /* Find Min and Max prediv */
+        while ((xtal/max_prediv) >= fcp_min)
+                max_prediv++;
+
+        max_prediv--;
+        min_prediv = max_prediv;
+        while ((xtal/min_prediv) <= fcp_max) {
+                min_prediv--;
+                if (min_prediv == 1)
+                        break;
+        }
+        deb_info("MIN prediv = %d : MAX prediv = %d", min_prediv, max_prediv);
+
+        min_prediv = 2;
+
+        for (prediv = min_prediv ; prediv < max_prediv; prediv++) {
+                fcp = xtal / prediv;
+                if (fcp > fcp_min && fcp < fcp_max) {
+                        for (loopdiv = 1 ; loopdiv < 64 ; loopdiv++) {
+                                fdem = ((xtal/prediv) * loopdiv);
+                                fs   = fdem / 4;
+                                /* test min/max system restrictions */
+
+                                if ((fdem >= fdem_min) && (fdem <= fdem_max) && (fs >= fe->dtv_property_cache.bandwidth_hz/1000)) {
+                                        spur = 0;
+                                        /* test fs harmonics positions */
+                                        for (harmonic_id = (fe->dtv_property_cache.frequency / (1000*fs)) ;  harmonic_id <= ((fe->dtv_property_cache.frequency / (1000*fs))+1) ; harmonic_id++) {
+                                                if (((fs*harmonic_id) >= ((fe->dtv_property_cache.frequency/1000) - (fe->dtv_property_cache.bandwidth_hz/2000))) &&  ((fs*harmonic_id) <= ((fe->dtv_property_cache.frequency/1000) + (fe->dtv_property_cache.bandwidth_hz/2000)))) {
+                                                        spur = 1;
+                                                        break;
+                                                }
+                                        }
+
+                                        if (!spur) {
+                                                adc->pll_loopdiv = loopdiv;
+                                                adc->pll_prediv = prediv;
+                                                adc->timf = 2396745143UL/fdem*(1 << 9);
+                                                adc->timf += ((2396745143UL%fdem) << 9)/fdem;
+                                                deb_info("loopdiv=%i prediv=%i timf=%i", loopdiv, prediv, adc->timf);
+                                                break;
+                                        }
+                                }
+                        }
+                }
+                if (!spur)
+                        break;
+        }
+
+
+        if (adc->pll_loopdiv == 0 && adc->pll_prediv == 0)
+                return -EINVAL;
+        else
+                return 0;
+}
+
+static int dib7090_agc_startup(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+        struct dibx000_bandwidth_config pll;
+        u16 target;
+        struct dib7090p_best_adc adc;
+        int ret;
+
+        ret = state->set_param_save(fe, fep);
+        if (ret < 0)
+                return ret;
+
+        memset(&pll, 0, sizeof(struct dibx000_bandwidth_config));
+        dib0090_pwm_gain_reset(fe);
+        target = (dib0090_get_wbd_offset(fe) * 8 + 1) / 2;
+        dib7000p_set_wbd_ref(fe, target);
+
+        if (dib7090p_get_best_sampling(fe, &adc) == 0) {
+                pll.pll_ratio  = adc.pll_loopdiv;
+                pll.pll_prediv = adc.pll_prediv;
+
+                dib7000p_update_pll(fe, &pll);
+                dib7000p_ctrl_timf(fe, DEMOD_TIMF_SET, adc.timf);
+        }
+        return 0;
+}
+
+static struct dib0090_wbd_slope dib7090_wbd_table[] = {
+        { 380,   81, 850, 64, 540,  4},
+        { 860,   51, 866, 21,  375, 4},
+        {1700,    0, 250, 0,   100, 6},
+        {2600,    0, 250, 0,   100, 6},
+        { 0xFFFF, 0,   0, 0,   0,   0},
+};
+
+struct dibx000_agc_config dib7090_agc_config[2] = {
+        {
+                .band_caps      = BAND_UHF,
+                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
+                * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
+                .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
+
+                .inv_gain       = 687,
+                .time_stabiliz  = 10,
+
+                .alpha_level    = 0,
+                .thlock         = 118,
+
+                .wbd_inv        = 0,
+                .wbd_ref        = 1200,
+                .wbd_sel        = 3,
+                .wbd_alpha      = 5,
+
+                .agc1_max       = 65535,
+                .agc1_min       = 0,
+
+                .agc2_max       = 65535,
+                .agc2_min       = 0,
+
+                .agc1_pt1       = 0,
+                .agc1_pt2       = 32,
+                .agc1_pt3       = 114,
+                .agc1_slope1    = 143,
+                .agc1_slope2    = 144,
+                .agc2_pt1       = 114,
+                .agc2_pt2       = 227,
+                .agc2_slope1    = 116,
+                .agc2_slope2    = 117,
+
+                .alpha_mant     = 18,
+                .alpha_exp      = 0,
+                .beta_mant      = 20,
+                .beta_exp       = 59,
+
+                .perform_agc_softsplit = 0,
+        } , {
+                .band_caps      = BAND_FM | BAND_VHF | BAND_CBAND,
+                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=1, P_agc_inv_pwm1=0, P_agc_inv_pwm2=0,
+                * P_agc_inh_dc_rv_est=0, P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 */
+                .setup          = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
+
+                .inv_gain       = 732,
+                .time_stabiliz  = 10,
+
+                .alpha_level    = 0,
+                .thlock         = 118,
+
+                .wbd_inv        = 0,
+                .wbd_ref        = 1200,
+                .wbd_sel        = 3,
+                .wbd_alpha      = 5,
+
+                .agc1_max       = 65535,
+                .agc1_min       = 0,
+
+                .agc2_max       = 65535,
+                .agc2_min       = 0,
+
+                .agc1_pt1       = 0,
+                .agc1_pt2       = 0,
+                .agc1_pt3       = 98,
+                .agc1_slope1    = 0,
+                .agc1_slope2    = 167,
+                .agc2_pt1       = 98,
+                .agc2_pt2       = 255,
+                .agc2_slope1    = 104,
+                .agc2_slope2    = 0,
+
+                .alpha_mant     = 18,
+                .alpha_exp      = 0,
+                .beta_mant      = 20,
+                .beta_exp       = 59,
+
+                .perform_agc_softsplit = 0,
+        }
+};
+
+static struct dibx000_bandwidth_config dib7090_clock_config_12_mhz = {
+        60000, 15000,
+        1, 5, 0, 0, 0,
+        0, 0, 1, 1, 2,
+        (3 << 14) | (1 << 12) | (524 << 0),
+        (0 << 25) | 0,
+        20452225,
+        15000000,
+};
+
+static struct dib7000p_config nim7090_dib7000p_config = {
+        .output_mpeg2_in_188_bytes  = 1,
+        .hostbus_diversity                      = 1,
+        .tuner_is_baseband                      = 1,
+        .update_lna                                     = NULL,
+
+        .agc_config_count                       = 2,
+        .agc                                            = dib7090_agc_config,
+
+        .bw                                                     = &dib7090_clock_config_12_mhz,
+
+        .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
+
+        .pwm_freq_div                           = 0,
+
+        .agc_control                            = dib7090_agc_restart,
+
+        .spur_protect                           = 0,
+        .disable_sample_and_hold        = 0,
+        .enable_current_mirror          = 0,
+        .diversity_delay                        = 0,
+
+        .output_mode                            = OUTMODE_MPEG2_FIFO,
+        .enMpegOutput                           = 1,
+};
+
+static struct dib7000p_config tfe7090pvr_dib7000p_config[2] = {
+        {
+                .output_mpeg2_in_188_bytes  = 1,
+                .hostbus_diversity                      = 1,
+                .tuner_is_baseband                      = 1,
+                .update_lna                                     = NULL,
+
+                .agc_config_count                       = 2,
+                .agc                                            = dib7090_agc_config,
+
+                .bw                                                     = &dib7090_clock_config_12_mhz,
+
+                .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
+
+                .pwm_freq_div                           = 0,
+
+                .agc_control                            = dib7090_agc_restart,
+
+                .spur_protect                           = 0,
+                .disable_sample_and_hold        = 0,
+                .enable_current_mirror          = 0,
+                .diversity_delay                        = 0,
+
+                .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
+                .default_i2c_addr                       = 0x90,
+                .enMpegOutput                           = 1,
+        }, {
+                .output_mpeg2_in_188_bytes  = 1,
+                .hostbus_diversity                      = 1,
+                .tuner_is_baseband                      = 1,
+                .update_lna                                     = NULL,
+
+                .agc_config_count                       = 2,
+                .agc                                            = dib7090_agc_config,
+
+                .bw                                                     = &dib7090_clock_config_12_mhz,
+
+                .gpio_dir                                       = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val                                       = DIB7000P_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos                           = DIB7000P_GPIO_DEFAULT_PWM_POS,
+
+                .pwm_freq_div                           = 0,
+
+                .agc_control                            = dib7090_agc_restart,
+
+                .spur_protect                           = 0,
+                .disable_sample_and_hold        = 0,
+                .enable_current_mirror          = 0,
+                .diversity_delay                        = 0,
+
+                .output_mode                            = OUTMODE_MPEG2_PAR_GATED_CLK,
+                .default_i2c_addr                       = 0x92,
+                .enMpegOutput                           = 0,
+        }
+};
+
+static const struct dib0090_config nim7090_dib0090_config = {
+        .io.clock_khz = 12000,
+        .io.pll_bypass = 0,
+        .io.pll_range = 0,
+        .io.pll_prediv = 3,
+        .io.pll_loopdiv = 6,
+        .io.adc_clock_ratio = 0,
+        .io.pll_int_loop_filt = 0,
+        .reset = dib7090_tuner_sleep,
+        .sleep = dib7090_tuner_sleep,
+
+        .freq_offset_khz_uhf = 0,
+        .freq_offset_khz_vhf = 0,
+
+        .get_adc_power = dib7090_get_adc_power,
+
+        .clkouttobamse = 1,
+        .analog_output = 0,
+
+        .wbd_vhf_offset = 0,
+        .wbd_cband_offset = 0,
+        .use_pwm_agc = 1,
+        .clkoutdrive = 0,
+
+        .fref_clock_ratio = 0,
+
+        .wbd = dib7090_wbd_table,
+
+        .ls_cfg_pad_drv = 0,
+        .data_tx_drv = 0,
+        .low_if = NULL,
+        .in_soc = 1,
+};
+
+static const struct dib0090_config tfe7090pvr_dib0090_config[2] = {
+        {
+                .io.clock_khz = 12000,
+                .io.pll_bypass = 0,
+                .io.pll_range = 0,
+                .io.pll_prediv = 3,
+                .io.pll_loopdiv = 6,
+                .io.adc_clock_ratio = 0,
+                .io.pll_int_loop_filt = 0,
+                .reset = dib7090_tuner_sleep,
+                .sleep = dib7090_tuner_sleep,
+
+                .freq_offset_khz_uhf = 50,
+                .freq_offset_khz_vhf = 70,
+
+                .get_adc_power = dib7090_get_adc_power,
+
+                .clkouttobamse = 1,
+                .analog_output = 0,
+
+                .wbd_vhf_offset = 0,
+                .wbd_cband_offset = 0,
+                .use_pwm_agc = 1,
+                .clkoutdrive = 0,
+
+                .fref_clock_ratio = 0,
+
+                .wbd = dib7090_wbd_table,
+
+                .ls_cfg_pad_drv = 0,
+                .data_tx_drv = 0,
+                .low_if = NULL,
+                .in_soc = 1,
+        }, {
+                .io.clock_khz = 12000,
+                .io.pll_bypass = 0,
+                .io.pll_range = 0,
+                .io.pll_prediv = 3,
+                .io.pll_loopdiv = 6,
+                .io.adc_clock_ratio = 0,
+                .io.pll_int_loop_filt = 0,
+                .reset = dib7090_tuner_sleep,
+                .sleep = dib7090_tuner_sleep,
+
+                .freq_offset_khz_uhf = -50,
+                .freq_offset_khz_vhf = -70,
+
+                .get_adc_power = dib7090_get_adc_power,
+
+                .clkouttobamse = 1,
+                .analog_output = 0,
+
+                .wbd_vhf_offset = 0,
+                .wbd_cband_offset = 0,
+                .use_pwm_agc = 1,
+                .clkoutdrive = 0,
+
+                .fref_clock_ratio = 0,
+
+                .wbd = dib7090_wbd_table,
+
+                .ls_cfg_pad_drv = 0,
+                .data_tx_drv = 0,
+                .low_if = NULL,
+                .in_soc = 1,
+        }
+};
+
+static int nim7090_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) {
+                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+                return -ENODEV;
+        }
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config);
+
+        return adap->fe == NULL ?  -ENODEV : 0;
+}
+
+static int nim7090_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
+
+        if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &nim7090_dib0090_config) == NULL)
+                return -ENODEV;
+
+        dib7000p_set_gpio(adap->fe, 8, 0, 1);
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
+        return 0;
+}
+
+static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_state *st = adap->dev->priv;
+
+        /* The TFE7090 requires the dib0700 to not be in master mode */
+        st->disable_streaming_master_mode = 1;
+
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(20);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        /* initialize IC 0 */
+        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) {
+                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+                return -ENODEV;
+        }
+
+        dib0700_set_i2c_speed(adap->dev, 340);
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x90, &tfe7090pvr_dib7000p_config[0]);
+        if (adap->fe == NULL)
+                return -ENODEV;
+
+        dib7090_slave_reset(adap->fe);
+
+        return 0;
+}
+
+static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap)
+{
+        struct i2c_adapter *i2c;
+
+        if (adap->dev->adapter[0].fe == NULL) {
+                err("the master dib7090 has to be initialized first");
+                return -ENODEV; /* the master device has not been initialized */
+        }
+
+        i2c = dib7000p_get_i2c_master(adap->dev->adapter[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1);
+        if (dib7000p_i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) {
+                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n", __func__);
+                return -ENODEV;
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, i2c, 0x92, &tfe7090pvr_dib7000p_config[1]);
+        dib0700_set_i2c_speed(adap->dev, 200);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int tfe7090pvr_tuner0_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
+
+        if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &tfe7090pvr_dib0090_config[0]) == NULL)
+                return -ENODEV;
+
+        dib7000p_set_gpio(adap->fe, 8, 0, 1);
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
+        return 0;
+}
+
+static int tfe7090pvr_tuner1_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c = dib7090_get_i2c_tuner(adap->fe);
+
+        if (dvb_attach(dib0090_register, adap->fe, tun_i2c, &tfe7090pvr_dib0090_config[1]) == NULL)
+                return -ENODEV;
+
+        dib7000p_set_gpio(adap->fe, 8, 0, 1);
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib7090_agc_startup;
+        return 0;
+}
+
+/* STK7070PD */
+static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
+        {
+                .output_mpeg2_in_188_bytes = 1,
+
+                .agc_config_count = 1,
+                .agc = &dib7070_agc_config,
+                .bw  = &dib7070_bw_config_12_mhz,
+                .tuner_is_baseband = 1,
+                .spur_protect = 1,
+
+                .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+
+                .hostbus_diversity = 1,
+        }, {
+                .output_mpeg2_in_188_bytes = 1,
+
+                .agc_config_count = 1,
+                .agc = &dib7070_agc_config,
+                .bw  = &dib7070_bw_config_12_mhz,
+                .tuner_is_baseband = 1,
+                .spur_protect = 1,
+
+                .gpio_dir = DIB7000P_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val = DIB7000P_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
+
+                .hostbus_diversity = 1,
+        }
+};
+
+static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap)
+{
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 2, 18,
+                                     stk7070pd_dib7000p_config) != 0) {
+                err("%s: dib7000p_i2c_enumeration failed.  Cannot continue\n",
+                    __func__);
+                return -ENODEV;
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80, &stk7070pd_dib7000p_config[0]);
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int stk7070pd_frontend_attach1(struct dvb_usb_adapter *adap)
+{
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x82, &stk7070pd_dib7000p_config[1]);
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+/* S5H1411 */
+static struct s5h1411_config pinnacle_801e_config = {
+        .output_mode   = S5H1411_PARALLEL_OUTPUT,
+        .gpio          = S5H1411_GPIO_OFF,
+        .mpeg_timing   = S5H1411_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
+        .qam_if        = S5H1411_IF_44000,
+        .vsb_if        = S5H1411_IF_44000,
+        .inversion     = S5H1411_INVERSION_OFF,
+        .status_mode   = S5H1411_DEMODLOCKING
+};
+
+/* Pinnacle PCTV HD Pro 801e GPIOs map:
+   GPIO0  - currently unknown
+   GPIO1  - xc5000 tuner reset
+   GPIO2  - CX25843 sleep
+   GPIO3  - currently unknown
+   GPIO4  - currently unknown
+   GPIO6  - currently unknown
+   GPIO7  - currently unknown
+   GPIO9  - currently unknown
+   GPIO10 - CX25843 reset
+ */
+static int s5h1411_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_state *st = adap->dev->priv;
+
+        /* Make use of the new i2c functions from FW 1.20 */
+        st->fw_use_new_i2c_api = 1;
+
+        /* The s5h1411 requires the dib0700 to not be in master mode */
+        st->disable_streaming_master_mode = 1;
+
+        /* All msleep values taken from Windows USB trace */
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0);
+        dib0700_set_gpio(adap->dev, GPIO3, GPIO_OUT, 0);
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(400);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+        msleep(60);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(30);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO9, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO4, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO7, GPIO_OUT, 1);
+        dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 0);
+        msleep(30);
+
+        /* Put the CX25843 to sleep for now since we're in digital mode */
+        dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
+
+        /* GPIOs are initialized, do the attach */
+        adap->fe = dvb_attach(s5h1411_attach, &pinnacle_801e_config,
+                              &adap->dev->i2c_adap);
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int dib0700_xc5000_tuner_callback(void *priv, int component,
+                                         int command, int arg)
+{
+        struct dvb_usb_adapter *adap = priv;
+
+        if (command == XC5000_TUNER_RESET) {
+                /* Reset the tuner */
+                dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 0);
+                msleep(10);
+                dib0700_set_gpio(adap->dev, GPIO1, GPIO_OUT, 1);
+                msleep(10);
+        } else {
+                err("xc5000: unknown tuner callback command: %d\n", command);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static struct xc5000_config s5h1411_xc5000_tunerconfig = {
+        .i2c_address      = 0x64,
+        .if_khz           = 5380,
+};
+
+static int xc5000_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        /* FIXME: generalize & move to common area */
+        adap->fe->callback = dib0700_xc5000_tuner_callback;
+
+        return dvb_attach(xc5000_attach, adap->fe, &adap->dev->i2c_adap,
+                          &s5h1411_xc5000_tunerconfig)
+                == NULL ? -ENODEV : 0;
+}
+
+static int dib0700_xc4000_tuner_callback(void *priv, int component,
+                                         int command, int arg)
+{
+        struct dvb_usb_adapter *adap = priv;
+
+        if (command == XC4000_TUNER_RESET) {
+                /* Reset the tuner */
+                dib7000p_set_gpio(adap->fe, 8, 0, 0);
+                msleep(10);
+                dib7000p_set_gpio(adap->fe, 8, 0, 1);
+        } else {
+                err("xc4000: unknown tuner callback command: %d\n", command);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static struct dibx000_agc_config stk7700p_7000p_xc4000_agc_config = {
+        .band_caps = BAND_UHF | BAND_VHF,
+        .setup = 0x64,
+        .inv_gain = 0x02c8,
+        .time_stabiliz = 0x15,
+        .alpha_level = 0x00,
+        .thlock = 0x76,
+        .wbd_inv = 0x01,
+        .wbd_ref = 0x0b33,
+        .wbd_sel = 0x00,
+        .wbd_alpha = 0x02,
+        .agc1_max = 0x00,
+        .agc1_min = 0x00,
+        .agc2_max = 0x9b26,
+        .agc2_min = 0x26ca,
+        .agc1_pt1 = 0x00,
+        .agc1_pt2 = 0x00,
+        .agc1_pt3 = 0x00,
+        .agc1_slope1 = 0x00,
+        .agc1_slope2 = 0x00,
+        .agc2_pt1 = 0x00,
+        .agc2_pt2 = 0x80,
+        .agc2_slope1 = 0x1d,
+        .agc2_slope2 = 0x1d,
+        .alpha_mant = 0x11,
+        .alpha_exp = 0x1b,
+        .beta_mant = 0x17,
+        .beta_exp = 0x33,
+        .perform_agc_softsplit = 0x00,
+};
+
+static struct dibx000_bandwidth_config stk7700p_xc4000_pll_config = {
+        60000, 30000,   /* internal, sampling */
+        1, 8, 3, 1, 0,  /* pll_cfg: prediv, ratio, range, reset, bypass */
+        0, 0, 1, 1, 0,  /* misc: refdiv, bypclk_div, IO_CLK_en_core, */
+                        /* ADClkSrc, modulo */
+        (3 << 14) | (1 << 12) | 524,    /* sad_cfg: refsel, sel, freq_15k */
+        39370534,       /* ifreq */
+        20452225,       /* timf */
+        30000000        /* xtal */
+};
+
+/* FIXME: none of these inputs are validated yet */
+static struct dib7000p_config pctv_340e_config = {
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_config_count = 1,
+        .agc = &stk7700p_7000p_xc4000_agc_config,
+        .bw  = &stk7700p_xc4000_pll_config,
+
+        .gpio_dir = DIB7000M_GPIO_DEFAULT_DIRECTIONS,
+        .gpio_val = DIB7000M_GPIO_DEFAULT_VALUES,
+        .gpio_pwm_pos = DIB7000M_GPIO_DEFAULT_PWM_POS,
+};
+
+/* PCTV 340e GPIOs map:
+   dib0700:
+   GPIO2  - CX25843 sleep
+   GPIO3  - CS5340 reset
+   GPIO5  - IRD
+   GPIO6  - Power Supply
+   GPIO8  - LNA (1=off 0=on)
+   GPIO10 - CX25843 reset
+   dib7000:
+   GPIO8  - xc4000 reset
+ */
+static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_state *st = adap->dev->priv;
+
+        /* Power Supply on */
+        dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 0);
+        msleep(50);
+        dib0700_set_gpio(adap->dev, GPIO6,  GPIO_OUT, 1);
+        msleep(100); /* Allow power supply to settle before probing */
+
+        /* cx25843 reset */
+        dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 0);
+        msleep(1); /* cx25843 datasheet say 350us required */
+        dib0700_set_gpio(adap->dev, GPIO10,  GPIO_OUT, 1);
+
+        /* LNA off for now */
+        dib0700_set_gpio(adap->dev, GPIO8,  GPIO_OUT, 1);
+
+        /* Put the CX25843 to sleep for now since we're in digital mode */
+        dib0700_set_gpio(adap->dev, GPIO2, GPIO_OUT, 1);
+
+        /* FIXME: not verified yet */
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(500);
+
+        if (dib7000pc_detection(&adap->dev->i2c_adap) == 0) {
+                /* Demodulator not found for some reason? */
+                return -ENODEV;
+        }
+
+        adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x12,
+                              &pctv_340e_config);
+        st->is_dib7000pc = 1;
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static struct xc4000_config dib7000p_xc4000_tunerconfig = {
+        .i2c_address      = 0x61,
+        .default_pm       = 1,
+        .dvb_amplitude    = 0,
+        .set_smoothedcvbs = 0,
+        .if_khz           = 5400
+};
+
+static int xc4000_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct i2c_adapter *tun_i2c;
+
+        /* The xc4000 is not on the main i2c bus */
+        tun_i2c = dib7000p_get_i2c_master(adap->fe,
+                                          DIBX000_I2C_INTERFACE_TUNER, 1);
+        if (tun_i2c == NULL) {
+                printk(KERN_ERR "Could not reach tuner i2c bus\n");
+                return 0;
+        }
+
+        /* Setup the reset callback */
+        adap->fe->callback = dib0700_xc4000_tuner_callback;
+
+        return dvb_attach(xc4000_attach, adap->fe, tun_i2c,
+                          &dib7000p_xc4000_tunerconfig)
+                == NULL ? -ENODEV : 0;
+}
+
+static struct lgdt3305_config hcw_lgdt3305_config = {
+        .i2c_addr           = 0x0e,
+        .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
+        .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
+        .tpvalid_polarity   = LGDT3305_TP_VALID_LOW,
+        .deny_i2c_rptr      = 0,
+        .spectral_inversion = 1,
+        .qam_if_khz         = 6000,
+        .vsb_if_khz         = 6000,
+        .usref_8vsb         = 0x0500,
+};
+
+static struct mxl5007t_config hcw_mxl5007t_config = {
+        .xtal_freq_hz = MxL_XTAL_25_MHZ,
+        .if_freq_hz = MxL_IF_6_MHZ,
+        .invert_if = 1,
+};
+
+/* TIGER-ATSC map:
+   GPIO0  - LNA_CTR  (H: LNA power enabled, L: LNA power disabled)
+   GPIO1  - ANT_SEL  (H: VPA, L: MCX)
+   GPIO4  - SCL2
+   GPIO6  - EN_TUNER
+   GPIO7  - SDA2
+   GPIO10 - DEM_RST
+
+   MXL is behind LG's i2c repeater.  LG is on SCL2/SDA2 gpios on the DIB
+ */
+static int lgdt3305_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_state *st = adap->dev->priv;
+
+        /* Make use of the new i2c functions from FW 1.20 */
+        st->fw_use_new_i2c_api = 1;
+
+        st->disable_streaming_master_mode = 1;
+
+        /* fe power enable */
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        msleep(30);
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(30);
+
+        /* demod reset */
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(30);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0);
+        msleep(30);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(30);
+
+        adap->fe = dvb_attach(lgdt3305_attach,
+                              &hcw_lgdt3305_config,
+                              &adap->dev->i2c_adap);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int mxl5007t_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        return dvb_attach(mxl5007t_attach, adap->fe,
+                          &adap->dev->i2c_adap, 0x60,
+                          &hcw_mxl5007t_config) == NULL ? -ENODEV : 0;
+}
+
+
+/* DVB-USB and USB stuff follows */
+struct usb_device_id dib0700_usb_id_table[] = {
+/* 0 */ { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700P_PC) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) },
+/* 5 */ { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) },
+        { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500) },
+        { USB_DEVICE(USB_VID_UNIWILL,   USB_PID_UNIWILL_STK7700P) },
+        { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_2) },
+/* 10 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_2) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV2000E) },
+        { USB_DEVICE(USB_VID_TERRATEC,
+                        USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7700D) },
+/* 15 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070P) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV_DVB_T_FLASH) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7070PD) },
+        { USB_DEVICE(USB_VID_PINNACLE,
+                        USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T) },
+        { USB_DEVICE(USB_VID_COMPRO,    USB_PID_COMPRO_VIDEOMATE_U500_PC) },
+/* 20 */{ USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_EXPRESS) },
+        { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U7000) },
+        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14BR) },
+        { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000) },
+        { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3100) },
+/* 25 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK_3) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_MYTV_T) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_USB_XE) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_EXPRESSCARD_320CX) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV72E) },
+/* 30 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73E) },
+        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_EC372S) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_HT_EXPRESS) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS) },
+        { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_STK7700P_2) },
+/* 35 */{ USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_3) },
+        { USB_DEVICE(USB_VID_GIGABYTE,  USB_PID_GIGABYTE_U8000) },
+        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700PH) },
+        { USB_DEVICE(USB_VID_ASUS,      USB_PID_ASUS_U3000H) },
+/* 40 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV801E_SE) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_EXPRESS) },
+        { USB_DEVICE(USB_VID_TERRATEC,
+                        USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2) },
+        { USB_DEVICE(USB_VID_SONY,      USB_PID_SONY_PLAYTV) },
+/* 45 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_PD378S) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC) },
+        { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_TIGER_ATSC_B210) },
+        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_MC770) },
+        { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT) },
+/* 50 */{ USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DTT_Dlx) },
+        { USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_H) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
+        { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
+        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
+/* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
+        { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV73ESE) },
+        { USB_DEVICE(USB_VID_PCTV,      USB_PID_PINNACLE_PCTV282E) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
+/* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
+        { USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x000, 0x3f00) },
+        { USB_DEVICE(USB_VID_EVOLUTEPC, USB_PID_TVWAY_PLUS) },
+/* 65 */{ USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK8096GP) },
+        { USB_DEVICE(USB_VID_ELGATO,    USB_PID_ELGATO_EYETV_DIVERSITY) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090M) },
+/* 70 */{ USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM8096MD) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM9090MD) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_NIM7090) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_TFE7090PVR) },
+        { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2) },
+/* 75 */{ USB_DEVICE(USB_VID_MEDION,    USB_PID_CREATIX_CTX1921) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV340E_SE) },
+        { 0 }           /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
+
+#define DIB0700_DEFAULT_DEVICE_PROPERTIES \
+        .caps              = DVB_USB_IS_AN_I2C_ADAPTER, \
+        .usb_ctrl          = DEVICE_SPECIFIC, \
+        .firmware          = "dvb-usb-dib0700-1.20.fw", \
+        .download_firmware = dib0700_download_firmware, \
+        .no_reconnect      = 1, \
+        .size_of_priv      = sizeof(struct dib0700_state), \
+        .i2c_algo          = &dib0700_i2c_algo, \
+        .identify_state    = dib0700_identify_state
+
+#define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \
+        .streaming_ctrl   = dib0700_streaming_ctrl, \
+        .stream = { \
+                .type = USB_BULK, \
+                .count = 4, \
+                .endpoint = ep, \
+                .u = { \
+                        .bulk = { \
+                                .buffersize = 39480, \
+                        } \
+                } \
+        }
+
+struct dvb_usb_device_properties dib0700_devices[] = {
+        {
+                DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk7700p_pid_filter,
+                                .pid_filter_ctrl  = stk7700p_pid_filter_ctrl,
+                                .frontend_attach  = stk7700p_frontend_attach,
+                                .tuner_attach     = stk7700p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+                        },
+                },
+
+                .num_device_descs = 8,
+                .devices = {
+                        {   "DiBcom STK7700P reference design",
+                                { &dib0700_usb_id_table[0], &dib0700_usb_id_table[1] },
+                                { NULL },
+                        },
+                        {   "Hauppauge Nova-T Stick",
+                                { &dib0700_usb_id_table[4], &dib0700_usb_id_table[9], NULL },
+                                { NULL },
+                        },
+                        {   "AVerMedia AVerTV DVB-T Volar",
+                                { &dib0700_usb_id_table[5], &dib0700_usb_id_table[10] },
+                                { NULL },
+                        },
+                        {   "Compro Videomate U500",
+                                { &dib0700_usb_id_table[6], &dib0700_usb_id_table[19] },
+                                { NULL },
+                        },
+                        {   "Uniwill STK7700P based (Hama and others)",
+                                { &dib0700_usb_id_table[7], NULL },
+                                { NULL },
+                        },
+                        {   "Leadtek Winfast DTV Dongle (STK7700P based)",
+                                { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
+                                { NULL },
+                        },
+                        {   "AVerMedia AVerTV DVB-T Express",
+                                { &dib0700_usb_id_table[20] },
+                                { NULL },
+                        },
+                        {   "Gigabyte U7000",
+                                { &dib0700_usb_id_table[21], NULL },
+                                { NULL },
+                        }
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .frontend_attach  = bristol_frontend_attach,
+                                .tuner_attach     = bristol_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+                        }, {
+                                .frontend_attach  = bristol_frontend_attach,
+                                .tuner_attach     = bristol_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
+                        }
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "Hauppauge Nova-T 500 Dual DVB-T",
+                                { &dib0700_usb_id_table[2], &dib0700_usb_id_table[3], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7700d_frontend_attach,
+                                .tuner_attach     = stk7700d_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+                        }, {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7700d_frontend_attach,
+                                .tuner_attach     = stk7700d_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
+                        }
+                },
+
+                .num_device_descs = 5,
+                .devices = {
+                        {   "Pinnacle PCTV 2000e",
+                                { &dib0700_usb_id_table[11], NULL },
+                                { NULL },
+                        },
+                        {   "Terratec Cinergy DT XS Diversity",
+                                { &dib0700_usb_id_table[12], NULL },
+                                { NULL },
+                        },
+                        {   "Hauppauge Nova-TD Stick/Elgato Eye-TV Diversity",
+                                { &dib0700_usb_id_table[13], NULL },
+                                { NULL },
+                        },
+                        {   "DiBcom STK7700D reference design",
+                                { &dib0700_usb_id_table[14], NULL },
+                                { NULL },
+                        },
+                        {   "YUAN High-Tech DiBcom STK7700D",
+                                { &dib0700_usb_id_table[55], NULL },
+                                { NULL },
+                        },
+
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7700P2_frontend_attach,
+                                .tuner_attach     = stk7700d_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+                        },
+                },
+
+                .num_device_descs = 3,
+                .devices = {
+                        {   "ASUS My Cinema U3000 Mini DVBT Tuner",
+                                { &dib0700_usb_id_table[23], NULL },
+                                { NULL },
+                        },
+                        {   "Yuan EC372S",
+                                { &dib0700_usb_id_table[31], NULL },
+                                { NULL },
+                        },
+                        {   "Terratec Cinergy T Express",
+                                { &dib0700_usb_id_table[42], NULL },
+                                { NULL },
+                        }
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7070p_frontend_attach,
+                                .tuner_attach     = dib7070p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv     = sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 11,
+                .devices = {
+                        {   "DiBcom STK7070P reference design",
+                                { &dib0700_usb_id_table[15], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV DVB-T Flash Stick",
+                                { &dib0700_usb_id_table[16], NULL },
+                                { NULL },
+                        },
+                        {   "Artec T14BR DVB-T",
+                                { &dib0700_usb_id_table[22], NULL },
+                                { NULL },
+                        },
+                        {   "ASUS My Cinema U3100 Mini DVBT Tuner",
+                                { &dib0700_usb_id_table[24], NULL },
+                                { NULL },
+                        },
+                        {   "Hauppauge Nova-T Stick",
+                                { &dib0700_usb_id_table[25], NULL },
+                                { NULL },
+                        },
+                        {   "Hauppauge Nova-T MyTV.t",
+                                { &dib0700_usb_id_table[26], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV 72e",
+                                { &dib0700_usb_id_table[29], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV 73e",
+                                { &dib0700_usb_id_table[30], NULL },
+                                { NULL },
+                        },
+                        {   "Elgato EyeTV DTT",
+                                { &dib0700_usb_id_table[49], NULL },
+                                { NULL },
+                        },
+                        {   "Yuan PD378S",
+                                { &dib0700_usb_id_table[45], NULL },
+                                { NULL },
+                        },
+                        {   "Elgato EyeTV Dtt Dlx PD378S",
+                                { &dib0700_usb_id_table[50], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7070p_frontend_attach,
+                                .tuner_attach     = dib7070p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv     = sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 3,
+                .devices = {
+                        {   "Pinnacle PCTV 73A",
+                                { &dib0700_usb_id_table[56], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV 73e SE",
+                                { &dib0700_usb_id_table[57], &dib0700_usb_id_table[65], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV 282e",
+                                { &dib0700_usb_id_table[58], &dib0700_usb_id_table[66], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7070pd_frontend_attach0,
+                                .tuner_attach     = dib7070p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv     = sizeof(struct dib0700_adapter_state),
+                        }, {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7070pd_frontend_attach1,
+                                .tuner_attach     = dib7070p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
+
+                                .size_of_priv     = sizeof(struct dib0700_adapter_state),
+                        }
+                },
+
+                .num_device_descs = 6,
+                .devices = {
+                        {   "DiBcom STK7070PD reference design",
+                                { &dib0700_usb_id_table[17], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV Dual DVB-T Diversity Stick",
+                                { &dib0700_usb_id_table[18], NULL },
+                                { NULL },
+                        },
+                        {   "Hauppauge Nova-TD Stick (52009)",
+                                { &dib0700_usb_id_table[35], NULL },
+                                { NULL },
+                        },
+                        {   "Hauppauge Nova-TD-500 (84xxx)",
+                                { &dib0700_usb_id_table[36], NULL },
+                                { NULL },
+                        },
+                        {  "Terratec Cinergy DT USB XS Diversity/ T5",
+                                { &dib0700_usb_id_table[43],
+                                        &dib0700_usb_id_table[53], NULL},
+                                { NULL },
+                        },
+                        {  "Sony PlayTV",
+                                { &dib0700_usb_id_table[44], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7070pd_frontend_attach0,
+                                .tuner_attach     = dib7070p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv     = sizeof(struct dib0700_adapter_state),
+                        }, {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7070pd_frontend_attach1,
+                                .tuner_attach     = dib7070p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
+
+                                .size_of_priv     = sizeof(struct dib0700_adapter_state),
+                        }
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "Elgato EyeTV Diversity",
+                                { &dib0700_usb_id_table[68], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7700ph_frontend_attach,
+                                .tuner_attach     = stk7700ph_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv = sizeof(struct
+                                                dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 9,
+                .devices = {
+                        {   "Terratec Cinergy HT USB XE",
+                                { &dib0700_usb_id_table[27], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle Expresscard 320cx",
+                                { &dib0700_usb_id_table[28], NULL },
+                                { NULL },
+                        },
+                        {   "Terratec Cinergy HT Express",
+                                { &dib0700_usb_id_table[32], NULL },
+                                { NULL },
+                        },
+                        {   "Gigabyte U8000-RH",
+                                { &dib0700_usb_id_table[37], NULL },
+                                { NULL },
+                        },
+                        {   "YUAN High-Tech STK7700PH",
+                                { &dib0700_usb_id_table[38], NULL },
+                                { NULL },
+                        },
+                        {   "Asus My Cinema-U3000Hybrid",
+                                { &dib0700_usb_id_table[39], NULL },
+                                { NULL },
+                        },
+                        {   "YUAN High-Tech MC770",
+                                { &dib0700_usb_id_table[48], NULL },
+                                { NULL },
+                        },
+                        {   "Leadtek WinFast DTV Dongle H",
+                                { &dib0700_usb_id_table[51], NULL },
+                                { NULL },
+                        },
+                        {   "YUAN High-Tech STK7700D",
+                                { &dib0700_usb_id_table[54], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .frontend_attach  = s5h1411_frontend_attach,
+                                .tuner_attach     = xc5000_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv = sizeof(struct
+                                                dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 2,
+                .devices = {
+                        {   "Pinnacle PCTV HD Pro USB Stick",
+                                { &dib0700_usb_id_table[40], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV HD USB Stick",
+                                { &dib0700_usb_id_table[41], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .frontend_attach  = lgdt3305_frontend_attach,
+                                .tuner_attach     = mxl5007t_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv = sizeof(struct
+                                                dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 2,
+                .devices = {
+                        {   "Hauppauge ATSC MiniCard (B200)",
+                                { &dib0700_usb_id_table[46], NULL },
+                                { NULL },
+                        },
+                        {   "Hauppauge ATSC MiniCard (B210)",
+                                { &dib0700_usb_id_table[47], NULL },
+                                { NULL },
+                        },
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter       = stk70x0p_pid_filter,
+                                .pid_filter_ctrl  = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = stk7770p_frontend_attach,
+                                .tuner_attach     = dib7770p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 4,
+                .devices = {
+                        {   "DiBcom STK7770P reference design",
+                                { &dib0700_usb_id_table[59], NULL },
+                                { NULL },
+                        },
+                        {   "Terratec Cinergy T USB XXS (HD)/ T3",
+                                { &dib0700_usb_id_table[33],
+                                        &dib0700_usb_id_table[52],
+                                        &dib0700_usb_id_table[60], NULL},
+                                { NULL },
+                        },
+                        {   "TechniSat AirStar TeleStick 2",
+                                { &dib0700_usb_id_table[74], NULL },
+                                { NULL },
+                        },
+                        {   "Medion CTX1921 DVB-T USB",
+                                { &dib0700_usb_id_table[75], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = stk80xx_pid_filter,
+                                .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
+                                .frontend_attach  = stk807x_frontend_attach,
+                                .tuner_attach     = dib807x_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 3,
+                .devices = {
+                        {   "DiBcom STK807xP reference design",
+                                { &dib0700_usb_id_table[62], NULL },
+                                { NULL },
+                        },
+                        {   "Prolink Pixelview SBTVD",
+                                { &dib0700_usb_id_table[63], NULL },
+                                { NULL },
+                        },
+                        {   "EvolutePC TVWay+",
+                                { &dib0700_usb_id_table[64], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_NEC_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = stk80xx_pid_filter,
+                                .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
+                                .frontend_attach  = stk807xpvr_frontend_attach0,
+                                .tuner_attach     = dib807x_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = stk80xx_pid_filter,
+                                .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
+                                .frontend_attach  = stk807xpvr_frontend_attach1,
+                                .tuner_attach     = dib807x_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "DiBcom STK807xPVR reference design",
+                                { &dib0700_usb_id_table[61], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
+                                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = stk80xx_pid_filter,
+                                .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
+                                .frontend_attach  = stk809x_frontend_attach,
+                                .tuner_attach     = dib809x_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "DiBcom STK8096GP reference design",
+                                { &dib0700_usb_id_table[67], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
+                                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = dib90x0_pid_filter,
+                                .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
+                                .frontend_attach  = stk9090m_frontend_attach,
+                                .tuner_attach     = dib9090_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "DiBcom STK9090M reference design",
+                                { &dib0700_usb_id_table[69], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
+                                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = stk80xx_pid_filter,
+                                .pid_filter_ctrl = stk80xx_pid_filter_ctrl,
+                                .frontend_attach  = nim8096md_frontend_attach,
+                                .tuner_attach     = nim8096md_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "DiBcom NIM8096MD reference design",
+                                { &dib0700_usb_id_table[70], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
+                                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = dib90x0_pid_filter,
+                                .pid_filter_ctrl = dib90x0_pid_filter_ctrl,
+                                .frontend_attach  = nim9090md_frontend_attach,
+                                .tuner_attach     = nim9090md_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "DiBcom NIM9090MD reference design",
+                                { &dib0700_usb_id_table[71], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
+                                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = stk70x0p_pid_filter,
+                                .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = nim7090_frontend_attach,
+                                .tuner_attach     = nim7090_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "DiBcom NIM7090 reference design",
+                                { &dib0700_usb_id_table[72], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
+                                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = stk70x0p_pid_filter,
+                                .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = tfe7090pvr_frontend0_attach,
+                                .tuner_attach     = tfe7090pvr_tuner0_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                        {
+                                .caps  = DVB_USB_ADAP_HAS_PID_FILTER |
+                                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                                .pid_filter_count = 32,
+                                .pid_filter = stk70x0p_pid_filter,
+                                .pid_filter_ctrl = stk70x0p_pid_filter_ctrl,
+                                .frontend_attach  = tfe7090pvr_frontend1_attach,
+                                .tuner_attach     = tfe7090pvr_tuner1_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "DiBcom TFE7090PVR reference design",
+                                { &dib0700_usb_id_table[73], NULL },
+                                { NULL },
+                        },
+                },
+
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .frontend_attach  = pctv340e_frontend_attach,
+                                .tuner_attach     = xc4000_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv = sizeof(struct
+                                                dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 2,
+                .devices = {
+                        {   "Pinnacle PCTV 340e HD Pro USB Stick",
+                                { &dib0700_usb_id_table[76], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV Hybrid Stick Solo",
+                                { &dib0700_usb_id_table[77], NULL },
+                                { NULL },
+                        },
+                },
+                .rc.core = {
+                        .rc_interval      = DEFAULT_RC_INTERVAL,
+                        .rc_codes         = RC_MAP_DIB0700_RC5_TABLE,
+                        .module_name      = "dib0700",
+                        .rc_query         = dib0700_rc_query_old_firmware,
+                        .allowed_protos   = RC_TYPE_RC5 |
+                                            RC_TYPE_RC6 |
+                                            RC_TYPE_NEC,
+                        .change_protocol  = dib0700_change_protocol,
+                },
+        },
+};
+
+int dib0700_device_count = ARRAY_SIZE(dib0700_devices);
diff --git a/drivers/media/dvb/dvb-usb/dib07x0.h b/drivers/media/dvb/dvb-usb/dib07x0.h
new file mode 100644
index 00000000000..7e62c101852
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dib07x0.h
@@ -0,0 +1,21 @@
+#ifndef _DIB07X0_H_
+#define _DIB07X0_H_
+
+enum dib07x0_gpios {
+        GPIO0  =  0,
+        GPIO1  =  2,
+        GPIO2  =  3,
+        GPIO3  =  4,
+        GPIO4  =  5,
+        GPIO5  =  6,
+        GPIO6  =  8,
+        GPIO7  = 10,
+        GPIO8  = 11,
+        GPIO9  = 14,
+        GPIO10 = 15,
+};
+
+#define GPIO_IN  0
+#define GPIO_OUT 1
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dibusb-common.c b/drivers/media/dvb/dvb-usb/dibusb-common.c
new file mode 100644
index 00000000000..4c2a689c820
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dibusb-common.c
@@ -0,0 +1,470 @@
+/* Common methods for dibusb-based-receivers.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dibusb.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info (|-able))." DVB_USB_DEBUG_STATUS);
+MODULE_LICENSE("GPL");
+
+#define deb_info(args...) dprintk(debug,0x01,args)
+
+/* common stuff used by the different dibusb modules */
+int dibusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        if (adap->priv != NULL) {
+                struct dibusb_state *st = adap->priv;
+                if (st->ops.fifo_ctrl != NULL)
+                        if (st->ops.fifo_ctrl(adap->fe,onoff)) {
+                                err("error while controlling the fifo of the demod.");
+                                return -ENODEV;
+                        }
+        }
+        return 0;
+}
+EXPORT_SYMBOL(dibusb_streaming_ctrl);
+
+int dibusb_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff)
+{
+        if (adap->priv != NULL) {
+                struct dibusb_state *st = adap->priv;
+                if (st->ops.pid_ctrl != NULL)
+                        st->ops.pid_ctrl(adap->fe,index,pid,onoff);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(dibusb_pid_filter);
+
+int dibusb_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        if (adap->priv != NULL) {
+                struct dibusb_state *st = adap->priv;
+                if (st->ops.pid_parse != NULL)
+                        if (st->ops.pid_parse(adap->fe,onoff) < 0)
+                                err("could not handle pid_parser");
+        }
+        return 0;
+}
+EXPORT_SYMBOL(dibusb_pid_filter_ctrl);
+
+int dibusb_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 b[3];
+        int ret;
+        b[0] = DIBUSB_REQ_SET_IOCTL;
+        b[1] = DIBUSB_IOCTL_CMD_POWER_MODE;
+        b[2] = onoff ? DIBUSB_IOCTL_POWER_WAKEUP : DIBUSB_IOCTL_POWER_SLEEP;
+        ret = dvb_usb_generic_write(d,b,3);
+        msleep(10);
+        return ret;
+}
+EXPORT_SYMBOL(dibusb_power_ctrl);
+
+int dibusb2_0_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        u8 b[3] = { 0 };
+        int ret;
+
+        if ((ret = dibusb_streaming_ctrl(adap,onoff)) < 0)
+                return ret;
+
+        if (onoff) {
+                b[0] = DIBUSB_REQ_SET_STREAMING_MODE;
+                b[1] = 0x00;
+                if ((ret = dvb_usb_generic_write(adap->dev,b,2)) < 0)
+                        return ret;
+        }
+
+        b[0] = DIBUSB_REQ_SET_IOCTL;
+        b[1] = onoff ? DIBUSB_IOCTL_CMD_ENABLE_STREAM : DIBUSB_IOCTL_CMD_DISABLE_STREAM;
+        return dvb_usb_generic_write(adap->dev,b,3);
+}
+EXPORT_SYMBOL(dibusb2_0_streaming_ctrl);
+
+int dibusb2_0_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        if (onoff) {
+                u8 b[3] = { DIBUSB_REQ_SET_IOCTL, DIBUSB_IOCTL_CMD_POWER_MODE, DIBUSB_IOCTL_POWER_WAKEUP };
+                return dvb_usb_generic_write(d,b,3);
+        } else
+                return 0;
+}
+EXPORT_SYMBOL(dibusb2_0_power_ctrl);
+
+static int dibusb_i2c_msg(struct dvb_usb_device *d, u8 addr,
+                          u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        u8 sndbuf[wlen+4]; /* lead(1) devaddr,direction(1) addr(2) data(wlen) (len(2) (when reading)) */
+        /* write only ? */
+        int wo = (rbuf == NULL || rlen == 0),
+                len = 2 + wlen + (wo ? 0 : 2);
+
+        sndbuf[0] = wo ? DIBUSB_REQ_I2C_WRITE : DIBUSB_REQ_I2C_READ;
+        sndbuf[1] = (addr << 1) | (wo ? 0 : 1);
+
+        memcpy(&sndbuf[2],wbuf,wlen);
+
+        if (!wo) {
+                sndbuf[wlen+2] = (rlen >> 8) & 0xff;
+                sndbuf[wlen+3] = rlen & 0xff;
+        }
+
+        return dvb_usb_generic_rw(d,sndbuf,len,rbuf,rlen,0);
+}
+
+/*
+ * I2C master xfer function
+ */
+static int dibusb_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                /* write/read request */
+                if (i+1 < num && (msg[i].flags & I2C_M_RD) == 0
+                                          && (msg[i+1].flags & I2C_M_RD)) {
+                        if (dibusb_i2c_msg(d, msg[i].addr, msg[i].buf,msg[i].len,
+                                                msg[i+1].buf,msg[i+1].len) < 0)
+                                break;
+                        i++;
+                } else if ((msg[i].flags & I2C_M_RD) == 0) {
+                        if (dibusb_i2c_msg(d, msg[i].addr, msg[i].buf,msg[i].len,NULL,0) < 0)
+                                break;
+                } else if (msg[i].addr != 0x50) {
+                        /* 0x50 is the address of the eeprom - we need to protect it
+                         * from dibusb's bad i2c implementation: reads without
+                         * writing the offset before are forbidden */
+                        if (dibusb_i2c_msg(d, msg[i].addr, NULL, 0, msg[i].buf, msg[i].len) < 0)
+                                break;
+                }
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+static u32 dibusb_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+struct i2c_algorithm dibusb_i2c_algo = {
+        .master_xfer   = dibusb_i2c_xfer,
+        .functionality = dibusb_i2c_func,
+};
+EXPORT_SYMBOL(dibusb_i2c_algo);
+
+int dibusb_read_eeprom_byte(struct dvb_usb_device *d, u8 offs, u8 *val)
+{
+        u8 wbuf[1] = { offs };
+        return dibusb_i2c_msg(d, 0x50, wbuf, 1, val, 1);
+}
+EXPORT_SYMBOL(dibusb_read_eeprom_byte);
+
+/* 3000MC/P stuff */
+// Config Adjacent channels  Perf -cal22
+static struct dibx000_agc_config dib3000p_mt2060_agc_config = {
+        .band_caps = BAND_VHF | BAND_UHF,
+        .setup     = (1 << 8) | (5 << 5) | (1 << 4) | (1 << 3) | (0 << 2) | (2 << 0),
+
+        .agc1_max = 48497,
+        .agc1_min = 23593,
+        .agc2_max = 46531,
+        .agc2_min = 24904,
+
+        .agc1_pt1 = 0x65,
+        .agc1_pt2 = 0x69,
+
+        .agc1_slope1 = 0x51,
+        .agc1_slope2 = 0x27,
+
+        .agc2_pt1 = 0,
+        .agc2_pt2 = 0x33,
+
+        .agc2_slope1 = 0x35,
+        .agc2_slope2 = 0x37,
+};
+
+static struct dib3000mc_config stk3000p_dib3000p_config = {
+        &dib3000p_mt2060_agc_config,
+
+        .max_time     = 0x196,
+        .ln_adc_level = 0x1cc7,
+
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_command1 = 1,
+        .agc_command2 = 1,
+};
+
+static struct dibx000_agc_config dib3000p_panasonic_agc_config = {
+        .band_caps = BAND_VHF | BAND_UHF,
+        .setup     = (1 << 8) | (5 << 5) | (1 << 4) | (1 << 3) | (0 << 2) | (2 << 0),
+
+        .agc1_max = 56361,
+        .agc1_min = 22282,
+        .agc2_max = 47841,
+        .agc2_min = 36045,
+
+        .agc1_pt1 = 0x3b,
+        .agc1_pt2 = 0x6b,
+
+        .agc1_slope1 = 0x55,
+        .agc1_slope2 = 0x1d,
+
+        .agc2_pt1 = 0,
+        .agc2_pt2 = 0x0a,
+
+        .agc2_slope1 = 0x95,
+        .agc2_slope2 = 0x1e,
+};
+
+#if defined(CONFIG_DVB_DIB3000MC) ||                                    \
+        (defined(CONFIG_DVB_DIB3000MC_MODULE) && defined(MODULE))
+
+static struct dib3000mc_config mod3000p_dib3000p_config = {
+        &dib3000p_panasonic_agc_config,
+
+        .max_time     = 0x51,
+        .ln_adc_level = 0x1cc7,
+
+        .output_mpeg2_in_188_bytes = 1,
+
+        .agc_command1 = 1,
+        .agc_command2 = 1,
+};
+
+int dibusb_dib3000mc_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (adap->dev->udev->descriptor.idVendor  == USB_VID_LITEON &&
+                        adap->dev->udev->descriptor.idProduct ==
+                        USB_PID_LITEON_DVB_T_WARM) {
+                msleep(1000);
+        }
+
+        if ((adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap, DEFAULT_DIB3000P_I2C_ADDRESS,  &mod3000p_dib3000p_config)) != NULL ||
+                (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap, DEFAULT_DIB3000MC_I2C_ADDRESS, &mod3000p_dib3000p_config)) != NULL) {
+                if (adap->priv != NULL) {
+                        struct dibusb_state *st = adap->priv;
+                        st->ops.pid_parse = dib3000mc_pid_parse;
+                        st->ops.pid_ctrl  = dib3000mc_pid_control;
+                }
+                return 0;
+        }
+        return -ENODEV;
+}
+EXPORT_SYMBOL(dibusb_dib3000mc_frontend_attach);
+
+static struct mt2060_config stk3000p_mt2060_config = {
+        0x60
+};
+
+int dibusb_dib3000mc_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dibusb_state *st = adap->priv;
+        u8 a,b;
+        u16 if1 = 1220;
+        struct i2c_adapter *tun_i2c;
+
+        // First IF calibration for Liteon Sticks
+        if (adap->dev->udev->descriptor.idVendor  == USB_VID_LITEON &&
+                adap->dev->udev->descriptor.idProduct == USB_PID_LITEON_DVB_T_WARM) {
+
+                dibusb_read_eeprom_byte(adap->dev,0x7E,&a);
+                dibusb_read_eeprom_byte(adap->dev,0x7F,&b);
+
+                if (a == 0x00)
+                        if1 += b;
+                else if (a == 0x80)
+                        if1 -= b;
+                else
+                        warn("LITE-ON DVB-T: Strange IF1 calibration :%2X %2X\n", a, b);
+
+        } else if (adap->dev->udev->descriptor.idVendor  == USB_VID_DIBCOM &&
+                   adap->dev->udev->descriptor.idProduct == USB_PID_DIBCOM_MOD3001_WARM) {
+                u8 desc;
+                dibusb_read_eeprom_byte(adap->dev, 7, &desc);
+                if (desc == 2) {
+                        a = 127;
+                        do {
+                                dibusb_read_eeprom_byte(adap->dev, a, &desc);
+                                a--;
+                        } while (a > 7 && (desc == 0xff || desc == 0x00));
+                        if (desc & 0x80)
+                                if1 -= (0xff - desc);
+                        else
+                                if1 += desc;
+                }
+        }
+
+        tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1);
+        if (dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk3000p_mt2060_config, if1) == NULL) {
+                /* not found - use panasonic pll parameters */
+                if (dvb_attach(dvb_pll_attach, adap->fe, 0x60, tun_i2c, DVB_PLL_ENV57H1XD5) == NULL)
+                        return -ENOMEM;
+        } else {
+                st->mt2060_present = 1;
+                /* set the correct parameters for the dib3000p */
+                dib3000mc_set_config(adap->fe, &stk3000p_dib3000p_config);
+        }
+        return 0;
+}
+EXPORT_SYMBOL(dibusb_dib3000mc_tuner_attach);
+#endif
+
+/*
+ * common remote control stuff
+ */
+struct rc_map_table rc_map_dibusb_table[] = {
+        /* Key codes for the little Artec T1/Twinhan/HAMA/ remote. */
+        { 0x0016, KEY_POWER },
+        { 0x0010, KEY_MUTE },
+        { 0x0003, KEY_1 },
+        { 0x0001, KEY_2 },
+        { 0x0006, KEY_3 },
+        { 0x0009, KEY_4 },
+        { 0x001d, KEY_5 },
+        { 0x001f, KEY_6 },
+        { 0x000d, KEY_7 },
+        { 0x0019, KEY_8 },
+        { 0x001b, KEY_9 },
+        { 0x0015, KEY_0 },
+        { 0x0005, KEY_CHANNELUP },
+        { 0x0002, KEY_CHANNELDOWN },
+        { 0x001e, KEY_VOLUMEUP },
+        { 0x000a, KEY_VOLUMEDOWN },
+        { 0x0011, KEY_RECORD },
+        { 0x0017, KEY_FAVORITES }, /* Heart symbol - Channel list. */
+        { 0x0014, KEY_PLAY },
+        { 0x001a, KEY_STOP },
+        { 0x0040, KEY_REWIND },
+        { 0x0012, KEY_FASTFORWARD },
+        { 0x000e, KEY_PREVIOUS }, /* Recall - Previous channel. */
+        { 0x004c, KEY_PAUSE },
+        { 0x004d, KEY_SCREEN }, /* Full screen mode. */
+        { 0x0054, KEY_AUDIO }, /* MTS - Switch to secondary audio. */
+        /* additional keys TwinHan VisionPlus, the Artec seemingly not have */
+        { 0x000c, KEY_CANCEL }, /* Cancel */
+        { 0x001c, KEY_EPG }, /* EPG */
+        { 0x0000, KEY_TAB }, /* Tab */
+        { 0x0048, KEY_INFO }, /* Preview */
+        { 0x0004, KEY_LIST }, /* RecordList */
+        { 0x000f, KEY_TEXT }, /* Teletext */
+        /* Key codes for the KWorld/ADSTech/JetWay remote. */
+        { 0x8612, KEY_POWER },
+        { 0x860f, KEY_SELECT }, /* source */
+        { 0x860c, KEY_UNKNOWN }, /* scan */
+        { 0x860b, KEY_EPG },
+        { 0x8610, KEY_MUTE },
+        { 0x8601, KEY_1 },
+        { 0x8602, KEY_2 },
+        { 0x8603, KEY_3 },
+        { 0x8604, KEY_4 },
+        { 0x8605, KEY_5 },
+        { 0x8606, KEY_6 },
+        { 0x8607, KEY_7 },
+        { 0x8608, KEY_8 },
+        { 0x8609, KEY_9 },
+        { 0x860a, KEY_0 },
+        { 0x8618, KEY_ZOOM },
+        { 0x861c, KEY_UNKNOWN }, /* preview */
+        { 0x8613, KEY_UNKNOWN }, /* snap */
+        { 0x8600, KEY_UNDO },
+        { 0x861d, KEY_RECORD },
+        { 0x860d, KEY_STOP },
+        { 0x860e, KEY_PAUSE },
+        { 0x8616, KEY_PLAY },
+        { 0x8611, KEY_BACK },
+        { 0x8619, KEY_FORWARD },
+        { 0x8614, KEY_UNKNOWN }, /* pip */
+        { 0x8615, KEY_ESC },
+        { 0x861a, KEY_UP },
+        { 0x861e, KEY_DOWN },
+        { 0x861f, KEY_LEFT },
+        { 0x861b, KEY_RIGHT },
+
+        /* Key codes for the DiBcom MOD3000 remote. */
+        { 0x8000, KEY_MUTE },
+        { 0x8001, KEY_TEXT },
+        { 0x8002, KEY_HOME },
+        { 0x8003, KEY_POWER },
+
+        { 0x8004, KEY_RED },
+        { 0x8005, KEY_GREEN },
+        { 0x8006, KEY_YELLOW },
+        { 0x8007, KEY_BLUE },
+
+        { 0x8008, KEY_DVD },
+        { 0x8009, KEY_AUDIO },
+        { 0x800a, KEY_IMAGES },      /* Pictures */
+        { 0x800b, KEY_VIDEO },
+
+        { 0x800c, KEY_BACK },
+        { 0x800d, KEY_UP },
+        { 0x800e, KEY_RADIO },
+        { 0x800f, KEY_EPG },
+
+        { 0x8010, KEY_LEFT },
+        { 0x8011, KEY_OK },
+        { 0x8012, KEY_RIGHT },
+        { 0x8013, KEY_UNKNOWN },    /* SAP */
+
+        { 0x8014, KEY_TV },
+        { 0x8015, KEY_DOWN },
+        { 0x8016, KEY_MENU },       /* DVD Menu */
+        { 0x8017, KEY_LAST },
+
+        { 0x8018, KEY_RECORD },
+        { 0x8019, KEY_STOP },
+        { 0x801a, KEY_PAUSE },
+        { 0x801b, KEY_PLAY },
+
+        { 0x801c, KEY_PREVIOUS },
+        { 0x801d, KEY_REWIND },
+        { 0x801e, KEY_FASTFORWARD },
+        { 0x801f, KEY_NEXT},
+
+        { 0x8040, KEY_1 },
+        { 0x8041, KEY_2 },
+        { 0x8042, KEY_3 },
+        { 0x8043, KEY_CHANNELUP },
+
+        { 0x8044, KEY_4 },
+        { 0x8045, KEY_5 },
+        { 0x8046, KEY_6 },
+        { 0x8047, KEY_CHANNELDOWN },
+
+        { 0x8048, KEY_7 },
+        { 0x8049, KEY_8 },
+        { 0x804a, KEY_9 },
+        { 0x804b, KEY_VOLUMEUP },
+
+        { 0x804c, KEY_CLEAR },
+        { 0x804d, KEY_0 },
+        { 0x804e, KEY_ENTER },
+        { 0x804f, KEY_VOLUMEDOWN },
+};
+EXPORT_SYMBOL(rc_map_dibusb_table);
+
+int dibusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        u8 key[5],cmd = DIBUSB_REQ_POLL_REMOTE;
+        dvb_usb_generic_rw(d,&cmd,1,key,5,0);
+        dvb_usb_nec_rc_key_to_event(d,key,event,state);
+        if (key[0] != 0)
+                deb_info("key: %x %x %x %x %x\n",key[0],key[1],key[2],key[3],key[4]);
+        return 0;
+}
+EXPORT_SYMBOL(dibusb_rc_query);
diff --git a/drivers/media/dvb/dvb-usb/dibusb-mb.c b/drivers/media/dvb/dvb-usb/dibusb-mb.c
new file mode 100644
index 00000000000..04d91bdd356
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dibusb-mb.c
@@ -0,0 +1,477 @@
+/* DVB USB compliant linux driver for mobile DVB-T USB devices based on
+ * reference designs made by DiBcom (http://www.dibcom.fr/) (DiB3000M-B)
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ * based on GPL code from DiBcom, which has
+ * Copyright (C) 2004 Amaury Demol for DiBcom (ademol@dibcom.fr)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dibusb.h"
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int dib3000mb_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dibusb_state *st = adap->priv;
+
+        return st->ops.tuner_pass_ctrl(fe, enable, st->tuner_addr);
+}
+
+static int dibusb_dib3000mb_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib3000_config demod_cfg;
+        struct dibusb_state *st = adap->priv;
+
+        demod_cfg.demod_address = 0x8;
+
+        if ((adap->fe = dvb_attach(dib3000mb_attach, &demod_cfg,
+                                   &adap->dev->i2c_adap, &st->ops)) == NULL)
+                return -ENODEV;
+
+        adap->fe->ops.i2c_gate_ctrl = dib3000mb_i2c_gate_ctrl;
+
+        return 0;
+}
+
+static int dibusb_thomson_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dibusb_state *st = adap->priv;
+
+        st->tuner_addr = 0x61;
+
+        dvb_attach(dvb_pll_attach, adap->fe, 0x61, &adap->dev->i2c_adap,
+                   DVB_PLL_TUA6010XS);
+        return 0;
+}
+
+static int dibusb_panasonic_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dibusb_state *st = adap->priv;
+
+        st->tuner_addr = 0x60;
+
+        dvb_attach(dvb_pll_attach, adap->fe, 0x60, &adap->dev->i2c_adap,
+                   DVB_PLL_TDA665X);
+        return 0;
+}
+
+/* Some of the Artec 1.1 device aren't equipped with the default tuner
+ * (Thomson Cable), but with a Panasonic ENV77H11D5.  This function figures
+ * this out. */
+static int dibusb_tuner_probe_and_attach(struct dvb_usb_adapter *adap)
+{
+        u8 b[2] = { 0,0 }, b2[1];
+        int ret = 0;
+        struct i2c_msg msg[2] = {
+                { .flags = 0,        .buf = b,  .len = 2 },
+                { .flags = I2C_M_RD, .buf = b2, .len = 1 },
+        };
+        struct dibusb_state *st = adap->priv;
+
+        /* the Panasonic sits on I2C addrass 0x60, the Thomson on 0x61 */
+        msg[0].addr = msg[1].addr = st->tuner_addr = 0x60;
+
+        if (adap->fe->ops.i2c_gate_ctrl)
+                adap->fe->ops.i2c_gate_ctrl(adap->fe,1);
+
+        if (i2c_transfer(&adap->dev->i2c_adap, msg, 2) != 2) {
+                err("tuner i2c write failed.");
+                ret = -EREMOTEIO;
+        }
+
+        if (adap->fe->ops.i2c_gate_ctrl)
+                adap->fe->ops.i2c_gate_ctrl(adap->fe,0);
+
+        if (b2[0] == 0xfe) {
+                info("This device has the Thomson Cable onboard. Which is default.");
+                ret = dibusb_thomson_tuner_attach(adap);
+        } else {
+                info("This device has the Panasonic ENV77H11D5 onboard.");
+                ret = dibusb_panasonic_tuner_attach(adap);
+        }
+
+        return ret;
+}
+
+/* USB Driver stuff */
+static struct dvb_usb_device_properties dibusb1_1_properties;
+static struct dvb_usb_device_properties dibusb1_1_an2235_properties;
+static struct dvb_usb_device_properties dibusb2_0b_properties;
+static struct dvb_usb_device_properties artec_t1_usb2_properties;
+
+static int dibusb_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        if (0 == dvb_usb_device_init(intf, &dibusb1_1_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &dibusb1_1_an2235_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &dibusb2_0b_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &artec_t1_usb2_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
+                return 0;
+
+        return -EINVAL;
+}
+
+/* do not change the order of the ID table */
+static struct usb_device_id dibusb_dib3000mb_table [] = {
+/* 00 */        { USB_DEVICE(USB_VID_WIDEVIEW,          USB_PID_AVERMEDIA_DVBT_USB_COLD) },
+/* 01 */        { USB_DEVICE(USB_VID_WIDEVIEW,          USB_PID_AVERMEDIA_DVBT_USB_WARM) },
+/* 02 */        { USB_DEVICE(USB_VID_COMPRO,            USB_PID_COMPRO_DVBU2000_COLD) },
+/* 03 */        { USB_DEVICE(USB_VID_COMPRO,            USB_PID_COMPRO_DVBU2000_WARM) },
+/* 04 */        { USB_DEVICE(USB_VID_COMPRO_UNK,        USB_PID_COMPRO_DVBU2000_UNK_COLD) },
+/* 05 */        { USB_DEVICE(USB_VID_DIBCOM,            USB_PID_DIBCOM_MOD3000_COLD) },
+/* 06 */        { USB_DEVICE(USB_VID_DIBCOM,            USB_PID_DIBCOM_MOD3000_WARM) },
+/* 07 */        { USB_DEVICE(USB_VID_EMPIA,             USB_PID_KWORLD_VSTREAM_COLD) },
+/* 08 */        { USB_DEVICE(USB_VID_EMPIA,             USB_PID_KWORLD_VSTREAM_WARM) },
+/* 09 */        { USB_DEVICE(USB_VID_GRANDTEC,          USB_PID_GRANDTEC_DVBT_USB_COLD) },
+/* 10 */        { USB_DEVICE(USB_VID_GRANDTEC,          USB_PID_GRANDTEC_DVBT_USB_WARM) },
+/* 11 */        { USB_DEVICE(USB_VID_GRANDTEC,          USB_PID_DIBCOM_MOD3000_COLD) },
+/* 12 */        { USB_DEVICE(USB_VID_GRANDTEC,          USB_PID_DIBCOM_MOD3000_WARM) },
+/* 13 */        { USB_DEVICE(USB_VID_HYPER_PALTEK,      USB_PID_UNK_HYPER_PALTEK_COLD) },
+/* 14 */        { USB_DEVICE(USB_VID_HYPER_PALTEK,      USB_PID_UNK_HYPER_PALTEK_WARM) },
+/* 15 */        { USB_DEVICE(USB_VID_VISIONPLUS,        USB_PID_TWINHAN_VP7041_COLD) },
+/* 16 */        { USB_DEVICE(USB_VID_VISIONPLUS,        USB_PID_TWINHAN_VP7041_WARM) },
+/* 17 */        { USB_DEVICE(USB_VID_TWINHAN,           USB_PID_TWINHAN_VP7041_COLD) },
+/* 18 */        { USB_DEVICE(USB_VID_TWINHAN,           USB_PID_TWINHAN_VP7041_WARM) },
+/* 19 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ULTIMA_TVBOX_COLD) },
+/* 20 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ULTIMA_TVBOX_WARM) },
+/* 21 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ULTIMA_TVBOX_AN2235_COLD) },
+/* 22 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ULTIMA_TVBOX_AN2235_WARM) },
+/* 23 */        { USB_DEVICE(USB_VID_ADSTECH,           USB_PID_ADSTECH_USB2_COLD) },
+
+/* device ID with default DIBUSB2_0-firmware and with the hacked firmware */
+/* 24 */        { USB_DEVICE(USB_VID_ADSTECH,           USB_PID_ADSTECH_USB2_WARM) },
+/* 25 */        { USB_DEVICE(USB_VID_KYE,               USB_PID_KYE_DVB_T_COLD) },
+/* 26 */        { USB_DEVICE(USB_VID_KYE,               USB_PID_KYE_DVB_T_WARM) },
+
+/* 27 */        { USB_DEVICE(USB_VID_KWORLD,            USB_PID_KWORLD_VSTREAM_COLD) },
+
+/* 28 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ULTIMA_TVBOX_USB2_COLD) },
+/* 29 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ULTIMA_TVBOX_USB2_WARM) },
+
+/*
+ * XXX: As Artec just 'forgot' to program the EEPROM on some Artec T1 devices
+ *      we don't catch these faulty IDs (namely 'Cypress FX1 USB controller') that
+ *      have been left on the device. If you don't have such a device but an Artec
+ *      device that's supposed to work with this driver but is not detected by it,
+ *      free to enable CONFIG_DVB_USB_DIBUSB_MB_FAULTY via your kernel config.
+ */
+
+#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
+/* 30 */        { USB_DEVICE(USB_VID_ANCHOR,            USB_PID_ULTIMA_TVBOX_ANCHOR_COLD) },
+#endif
+
+                        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, dibusb_dib3000mb_table);
+
+static struct dvb_usb_device_properties dibusb1_1_properties = {
+        .caps =  DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_AN2135,
+
+        .firmware = "dvb-usb-dibusb-5.0.0.11.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .pid_filter_count = 16,
+
+                        .streaming_ctrl   = dibusb_streaming_ctrl,
+                        .pid_filter       = dibusb_pid_filter,
+                        .pid_filter_ctrl  = dibusb_pid_filter_ctrl,
+                        .frontend_attach  = dibusb_dib3000mb_frontend_attach,
+                        .tuner_attach     = dibusb_tuner_probe_and_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                        .size_of_priv     = sizeof(struct dibusb_state),
+                }
+        },
+
+        .power_ctrl       = dibusb_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval      = DEFAULT_RC_INTERVAL,
+                .rc_map_table     = rc_map_dibusb_table,
+                .rc_map_size      = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
+                .rc_query         = dibusb_rc_query,
+        },
+
+        .i2c_algo         = &dibusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 9,
+        .devices = {
+                {       "AVerMedia AverTV DVBT USB1.1",
+                        { &dibusb_dib3000mb_table[0],  NULL },
+                        { &dibusb_dib3000mb_table[1],  NULL },
+                },
+                {       "Compro Videomate DVB-U2000 - DVB-T USB1.1 (please confirm to linux-dvb)",
+                        { &dibusb_dib3000mb_table[2], &dibusb_dib3000mb_table[4], NULL},
+                        { &dibusb_dib3000mb_table[3], NULL },
+                },
+                {       "DiBcom USB1.1 DVB-T reference design (MOD3000)",
+                        { &dibusb_dib3000mb_table[5],  NULL },
+                        { &dibusb_dib3000mb_table[6],  NULL },
+                },
+                {       "KWorld V-Stream XPERT DTV - DVB-T USB1.1",
+                        { &dibusb_dib3000mb_table[7], NULL },
+                        { &dibusb_dib3000mb_table[8], NULL },
+                },
+                {       "Grandtec USB1.1 DVB-T",
+                        { &dibusb_dib3000mb_table[9],  &dibusb_dib3000mb_table[11], NULL },
+                        { &dibusb_dib3000mb_table[10], &dibusb_dib3000mb_table[12], NULL },
+                },
+                {       "Unknown USB1.1 DVB-T device ???? please report the name to the author",
+                        { &dibusb_dib3000mb_table[13], NULL },
+                        { &dibusb_dib3000mb_table[14], NULL },
+                },
+                {       "TwinhanDTV USB-Ter USB1.1 / Magic Box I / HAMA USB1.1 DVB-T device",
+                        { &dibusb_dib3000mb_table[15], &dibusb_dib3000mb_table[17], NULL},
+                        { &dibusb_dib3000mb_table[16], &dibusb_dib3000mb_table[18], NULL},
+                },
+                {       "Artec T1 USB1.1 TVBOX with AN2135",
+                        { &dibusb_dib3000mb_table[19], NULL },
+                        { &dibusb_dib3000mb_table[20], NULL },
+                },
+                {       "VideoWalker DVB-T USB",
+                        { &dibusb_dib3000mb_table[25], NULL },
+                        { &dibusb_dib3000mb_table[26], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties dibusb1_1_an2235_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = CYPRESS_AN2235,
+
+        .firmware = "dvb-usb-dibusb-an2235-01.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_ADAP_HAS_PID_FILTER,
+                        .pid_filter_count = 16,
+
+                        .streaming_ctrl   = dibusb_streaming_ctrl,
+                        .pid_filter       = dibusb_pid_filter,
+                        .pid_filter_ctrl  = dibusb_pid_filter_ctrl,
+                        .frontend_attach  = dibusb_dib3000mb_frontend_attach,
+                        .tuner_attach     = dibusb_tuner_probe_and_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                        .size_of_priv     = sizeof(struct dibusb_state),
+                },
+        },
+        .power_ctrl       = dibusb_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval      = DEFAULT_RC_INTERVAL,
+                .rc_map_table     = rc_map_dibusb_table,
+                .rc_map_size      = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
+                .rc_query         = dibusb_rc_query,
+        },
+
+        .i2c_algo         = &dibusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
+        .num_device_descs = 2,
+#else
+        .num_device_descs = 1,
+#endif
+        .devices = {
+                {       "Artec T1 USB1.1 TVBOX with AN2235",
+                        { &dibusb_dib3000mb_table[21], NULL },
+                        { &dibusb_dib3000mb_table[22], NULL },
+                },
+#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
+                {       "Artec T1 USB1.1 TVBOX with AN2235 (faulty USB IDs)",
+                        { &dibusb_dib3000mb_table[30], NULL },
+                        { NULL },
+                },
+                { NULL },
+#endif
+        }
+};
+
+static struct dvb_usb_device_properties dibusb2_0b_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+
+        .firmware = "dvb-usb-adstech-usb2-02.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .pid_filter_count = 16,
+
+                        .streaming_ctrl   = dibusb2_0_streaming_ctrl,
+                        .pid_filter       = dibusb_pid_filter,
+                        .pid_filter_ctrl  = dibusb_pid_filter_ctrl,
+                        .frontend_attach  = dibusb_dib3000mb_frontend_attach,
+                        .tuner_attach     = dibusb_thomson_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x06,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                        .size_of_priv     = sizeof(struct dibusb_state),
+                }
+        },
+        .power_ctrl       = dibusb2_0_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval      = DEFAULT_RC_INTERVAL,
+                .rc_map_table     = rc_map_dibusb_table,
+                .rc_map_size      = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
+                .rc_query         = dibusb_rc_query,
+        },
+
+        .i2c_algo         = &dibusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 2,
+        .devices = {
+                {       "KWorld/ADSTech Instant DVB-T USB2.0",
+                        { &dibusb_dib3000mb_table[23], NULL },
+                        { &dibusb_dib3000mb_table[24], NULL },
+                },
+                {       "KWorld Xpert DVB-T USB2.0",
+                        { &dibusb_dib3000mb_table[27], NULL },
+                        { NULL }
+                },
+                { NULL },
+        }
+};
+
+static struct dvb_usb_device_properties artec_t1_usb2_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+
+        .firmware = "dvb-usb-dibusb-6.0.0.8.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .pid_filter_count = 16,
+
+                        .streaming_ctrl   = dibusb2_0_streaming_ctrl,
+                        .pid_filter       = dibusb_pid_filter,
+                        .pid_filter_ctrl  = dibusb_pid_filter_ctrl,
+                        .frontend_attach  = dibusb_dib3000mb_frontend_attach,
+                        .tuner_attach     = dibusb_tuner_probe_and_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x06,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                        .size_of_priv     = sizeof(struct dibusb_state),
+                }
+        },
+        .power_ctrl       = dibusb2_0_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval      = DEFAULT_RC_INTERVAL,
+                .rc_map_table     = rc_map_dibusb_table,
+                .rc_map_size      = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
+                .rc_query         = dibusb_rc_query,
+        },
+
+        .i2c_algo         = &dibusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {       "Artec T1 USB2.0",
+                        { &dibusb_dib3000mb_table[28], NULL },
+                        { &dibusb_dib3000mb_table[29], NULL },
+                },
+                { NULL },
+        }
+};
+
+static struct usb_driver dibusb_driver = {
+        .name           = "dvb_usb_dibusb_mb",
+        .probe          = dibusb_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = dibusb_dib3000mb_table,
+};
+
+/* module stuff */
+static int __init dibusb_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&dibusb_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit dibusb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&dibusb_driver);
+}
+
+module_init (dibusb_module_init);
+module_exit (dibusb_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for DiBcom USB DVB-T devices (DiB3000M-B based)");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/dibusb-mc.c b/drivers/media/dvb/dvb-usb/dibusb-mc.c
new file mode 100644
index 00000000000..c1d9094b61e
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dibusb-mc.c
@@ -0,0 +1,165 @@
+/* DVB USB compliant linux driver for mobile DVB-T USB devices based on
+ * reference designs made by DiBcom (http://www.dibcom.fr/) (DiB3000M-C/P)
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ * based on GPL code from DiBcom, which has
+ * Copyright (C) 2004 Amaury Demol for DiBcom (ademol@dibcom.fr)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dibusb.h"
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+/* USB Driver stuff */
+static struct dvb_usb_device_properties dibusb_mc_properties;
+
+static int dibusb_mc_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        return dvb_usb_device_init(intf, &dibusb_mc_properties, THIS_MODULE,
+                                   NULL, adapter_nr);
+}
+
+/* do not change the order of the ID table */
+static struct usb_device_id dibusb_dib3000mc_table [] = {
+/* 00 */        { USB_DEVICE(USB_VID_DIBCOM,            USB_PID_DIBCOM_MOD3001_COLD) },
+/* 01 */        { USB_DEVICE(USB_VID_DIBCOM,            USB_PID_DIBCOM_MOD3001_WARM) },
+/* 02 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ULTIMA_TVBOX_USB2_COLD) },
+/* 03 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ULTIMA_TVBOX_USB2_WARM) }, // ( ? )
+/* 04 */        { USB_DEVICE(USB_VID_LITEON,            USB_PID_LITEON_DVB_T_COLD) },
+/* 05 */        { USB_DEVICE(USB_VID_LITEON,            USB_PID_LITEON_DVB_T_WARM) },
+/* 06 */        { USB_DEVICE(USB_VID_EMPIA,             USB_PID_DIGIVOX_MINI_SL_COLD) },
+/* 07 */        { USB_DEVICE(USB_VID_EMPIA,             USB_PID_DIGIVOX_MINI_SL_WARM) },
+/* 08 */        { USB_DEVICE(USB_VID_GRANDTEC,          USB_PID_GRANDTEC_DVBT_USB2_COLD) },
+/* 09 */        { USB_DEVICE(USB_VID_GRANDTEC,          USB_PID_GRANDTEC_DVBT_USB2_WARM) },
+/* 10 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14_COLD) },
+/* 11 */        { USB_DEVICE(USB_VID_ULTIMA_ELECTRONIC, USB_PID_ARTEC_T14_WARM) },
+/* 12 */        { USB_DEVICE(USB_VID_LEADTEK,           USB_PID_WINFAST_DTV_DONGLE_COLD) },
+/* 13 */        { USB_DEVICE(USB_VID_LEADTEK,           USB_PID_WINFAST_DTV_DONGLE_WARM) },
+/* 14 */        { USB_DEVICE(USB_VID_HUMAX_COEX,        USB_PID_DVB_T_USB_STICK_HIGH_SPEED_COLD) },
+/* 15 */        { USB_DEVICE(USB_VID_HUMAX_COEX,        USB_PID_DVB_T_USB_STICK_HIGH_SPEED_WARM) },
+                        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, dibusb_dib3000mc_table);
+
+static struct dvb_usb_device_properties dibusb_mc_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-dibusb-6.0.0.8.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .pid_filter_count = 32,
+                        .streaming_ctrl   = dibusb2_0_streaming_ctrl,
+                        .pid_filter       = dibusb_pid_filter,
+                        .pid_filter_ctrl  = dibusb_pid_filter_ctrl,
+                        .frontend_attach  = dibusb_dib3000mc_frontend_attach,
+                        .tuner_attach     = dibusb_dib3000mc_tuner_attach,
+
+        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 8,
+                                .endpoint = 0x06,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                        .size_of_priv     = sizeof(struct dibusb_state),
+                }
+        },
+        .power_ctrl       = dibusb2_0_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval      = DEFAULT_RC_INTERVAL,
+                .rc_map_table     = rc_map_dibusb_table,
+                .rc_map_size      = 111, /* FIXME */
+                .rc_query         = dibusb_rc_query,
+        },
+
+        .i2c_algo         = &dibusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 8,
+        .devices = {
+                {   "DiBcom USB2.0 DVB-T reference design (MOD3000P)",
+                        { &dibusb_dib3000mc_table[0], NULL },
+                        { &dibusb_dib3000mc_table[1], NULL },
+                },
+                {   "Artec T1 USB2.0 TVBOX (please check the warm ID)",
+                        { &dibusb_dib3000mc_table[2], NULL },
+                        { &dibusb_dib3000mc_table[3], NULL },
+                },
+                {   "LITE-ON USB2.0 DVB-T Tuner",
+                    /* Also rebranded as Intuix S800, Toshiba */
+                        { &dibusb_dib3000mc_table[4], NULL },
+                        { &dibusb_dib3000mc_table[5], NULL },
+                },
+                {   "MSI Digivox Mini SL",
+                        { &dibusb_dib3000mc_table[6], NULL },
+                        { &dibusb_dib3000mc_table[7], NULL },
+                },
+                {   "GRAND - USB2.0 DVB-T adapter",
+                        { &dibusb_dib3000mc_table[8], NULL },
+                        { &dibusb_dib3000mc_table[9], NULL },
+                },
+                {   "Artec T14 - USB2.0 DVB-T",
+                        { &dibusb_dib3000mc_table[10], NULL },
+                        { &dibusb_dib3000mc_table[11], NULL },
+                },
+                {   "Leadtek - USB2.0 Winfast DTV dongle",
+                        { &dibusb_dib3000mc_table[12], NULL },
+                        { &dibusb_dib3000mc_table[13], NULL },
+                },
+                {   "Humax/Coex DVB-T USB Stick 2.0 High Speed",
+                        { &dibusb_dib3000mc_table[14], NULL },
+                        { &dibusb_dib3000mc_table[15], NULL },
+                },
+                { NULL },
+        }
+};
+
+static struct usb_driver dibusb_mc_driver = {
+        .name           = "dvb_usb_dibusb_mc",
+        .probe          = dibusb_mc_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = dibusb_dib3000mc_table,
+};
+
+/* module stuff */
+static int __init dibusb_mc_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&dibusb_mc_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit dibusb_mc_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&dibusb_mc_driver);
+}
+
+module_init (dibusb_mc_module_init);
+module_exit (dibusb_mc_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for DiBcom USB2.0 DVB-T (DiB3000M-C/P based) devices");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/dibusb.h b/drivers/media/dvb/dvb-usb/dibusb.h
new file mode 100644
index 00000000000..e47c321b3ff
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dibusb.h
@@ -0,0 +1,131 @@
+/* Header file for all dibusb-based-receivers.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_DIBUSB_H_
+#define _DVB_USB_DIBUSB_H_
+
+#ifndef DVB_USB_LOG_PREFIX
+ #define DVB_USB_LOG_PREFIX "dibusb"
+#endif
+#include "dvb-usb.h"
+
+#include "dib3000.h"
+#include "dib3000mc.h"
+#include "mt2060.h"
+
+/*
+ * protocol of all dibusb related devices
+ */
+
+/*
+ * bulk msg to/from endpoint 0x01
+ *
+ * general structure:
+ * request_byte parameter_bytes
+ */
+
+#define DIBUSB_REQ_START_READ                   0x00
+#define DIBUSB_REQ_START_DEMOD                  0x01
+
+/*
+ * i2c read
+ * bulk write: 0x02 ((7bit i2c_addr << 1) & 0x01) register_bytes length_word
+ * bulk read:  byte_buffer (length_word bytes)
+ */
+#define DIBUSB_REQ_I2C_READ                     0x02
+
+/*
+ * i2c write
+ * bulk write: 0x03 (7bit i2c_addr << 1) register_bytes value_bytes
+ */
+#define DIBUSB_REQ_I2C_WRITE                    0x03
+
+/*
+ * polling the value of the remote control
+ * bulk write: 0x04
+ * bulk read:  byte_buffer (5 bytes)
+ */
+#define DIBUSB_REQ_POLL_REMOTE       0x04
+
+/* additional status values for Hauppauge Remote Control Protocol */
+#define DIBUSB_RC_HAUPPAUGE_KEY_PRESSED 0x01
+#define DIBUSB_RC_HAUPPAUGE_KEY_EMPTY   0x03
+
+/* streaming mode:
+ * bulk write: 0x05 mode_byte
+ *
+ * mode_byte is mostly 0x00
+ */
+#define DIBUSB_REQ_SET_STREAMING_MODE   0x05
+
+/* interrupt the internal read loop, when blocking */
+#define DIBUSB_REQ_INTR_READ                    0x06
+
+/* io control
+ * 0x07 cmd_byte param_bytes
+ *
+ * param_bytes can be up to 32 bytes
+ *
+ * cmd_byte function    parameter name
+ * 0x00     power mode
+ *                      0x00      sleep
+ *                      0x01      wakeup
+ *
+ * 0x01     enable streaming
+ * 0x02     disable streaming
+ *
+ *
+ */
+#define DIBUSB_REQ_SET_IOCTL                    0x07
+
+/* IOCTL commands */
+
+/* change the power mode in firmware */
+#define DIBUSB_IOCTL_CMD_POWER_MODE             0x00
+#define DIBUSB_IOCTL_POWER_SLEEP                        0x00
+#define DIBUSB_IOCTL_POWER_WAKEUP                       0x01
+
+/* modify streaming of the FX2 */
+#define DIBUSB_IOCTL_CMD_ENABLE_STREAM  0x01
+#define DIBUSB_IOCTL_CMD_DISABLE_STREAM 0x02
+
+struct dibusb_state {
+        struct dib_fe_xfer_ops ops;
+        int mt2060_present;
+        u8 tuner_addr;
+};
+
+struct dibusb_device_state {
+        /* for RC5 remote control */
+        int old_toggle;
+        int last_repeat_count;
+};
+
+extern struct i2c_algorithm dibusb_i2c_algo;
+
+extern int dibusb_dib3000mc_frontend_attach(struct dvb_usb_adapter *);
+extern int dibusb_dib3000mc_tuner_attach (struct dvb_usb_adapter *);
+
+extern int dibusb_streaming_ctrl(struct dvb_usb_adapter *, int);
+extern int dibusb_pid_filter(struct dvb_usb_adapter *, int, u16, int);
+extern int dibusb_pid_filter_ctrl(struct dvb_usb_adapter *, int);
+extern int dibusb2_0_streaming_ctrl(struct dvb_usb_adapter *, int);
+
+extern int dibusb_power_ctrl(struct dvb_usb_device *, int);
+extern int dibusb2_0_power_ctrl(struct dvb_usb_device *, int);
+
+#define DEFAULT_RC_INTERVAL 150
+//#define DEFAULT_RC_INTERVAL 100000
+
+extern struct rc_map_table rc_map_dibusb_table[];
+extern int dibusb_rc_query(struct dvb_usb_device *, u32 *, int *);
+extern int dibusb_read_eeprom_byte(struct dvb_usb_device *, u8, u8 *);
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/digitv.c b/drivers/media/dvb/dvb-usb/digitv.c
new file mode 100644
index 00000000000..f6344cdd360
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/digitv.c
@@ -0,0 +1,365 @@
+/* DVB USB compliant linux driver for Nebula Electronics uDigiTV DVB-T USB2.0
+ * receiver
+ *
+ * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ * partly based on the SDK published by Nebula Electronics
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "digitv.h"
+
+#include "mt352.h"
+#include "nxt6000.h"
+
+/* debug */
+static int dvb_usb_digitv_debug;
+module_param_named(debug,dvb_usb_digitv_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+#define deb_rc(args...)   dprintk(dvb_usb_digitv_debug,0x01,args)
+
+static int digitv_ctrl_msg(struct dvb_usb_device *d,
+                u8 cmd, u8 vv, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
+{
+        int wo = (rbuf == NULL || rlen == 0); /* write-only */
+        u8 sndbuf[7],rcvbuf[7];
+        memset(sndbuf,0,7); memset(rcvbuf,0,7);
+
+        sndbuf[0] = cmd;
+        sndbuf[1] = vv;
+        sndbuf[2] = wo ? wlen : rlen;
+
+        if (wo) {
+                memcpy(&sndbuf[3],wbuf,wlen);
+                dvb_usb_generic_write(d,sndbuf,7);
+        } else {
+                dvb_usb_generic_rw(d,sndbuf,7,rcvbuf,7,10);
+                memcpy(rbuf,&rcvbuf[3],rlen);
+        }
+        return 0;
+}
+
+/* I2C */
+static int digitv_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        if (num > 2)
+                warn("more than 2 i2c messages at a time is not handled yet. TODO.");
+
+        for (i = 0; i < num; i++) {
+                /* write/read request */
+                if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
+                        if (digitv_ctrl_msg(d, USB_READ_COFDM, msg[i].buf[0], NULL, 0,
+                                                msg[i+1].buf,msg[i+1].len) < 0)
+                                break;
+                        i++;
+                } else
+                        if (digitv_ctrl_msg(d,USB_WRITE_COFDM, msg[i].buf[0],
+                                                &msg[i].buf[1],msg[i].len-1,NULL,0) < 0)
+                                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+static u32 digitv_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm digitv_i2c_algo = {
+        .master_xfer   = digitv_i2c_xfer,
+        .functionality = digitv_i2c_func,
+};
+
+/* Callbacks for DVB USB */
+static int digitv_identify_state (struct usb_device *udev, struct
+                dvb_usb_device_properties *props, struct dvb_usb_device_description **desc,
+                int *cold)
+{
+        *cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0;
+        return 0;
+}
+
+static int digitv_mt352_demod_init(struct dvb_frontend *fe)
+{
+        static u8 reset_buf[] = { 0x89, 0x38,  0x8a, 0x2d, 0x50, 0x80 };
+        static u8 init_buf[] = { 0x68, 0xa0,  0x8e, 0x40,  0x53, 0x50,
+                        0x67, 0x20,  0x7d, 0x01,  0x7c, 0x00,  0x7a, 0x00,
+                        0x79, 0x20,  0x57, 0x05,  0x56, 0x31,  0x88, 0x0f,
+                        0x75, 0x32 };
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(reset_buf); i += 2)
+                mt352_write(fe, &reset_buf[i], 2);
+
+        msleep(1);
+
+        for (i = 0; i < ARRAY_SIZE(init_buf); i += 2)
+                mt352_write(fe, &init_buf[i], 2);
+
+        return 0;
+}
+
+static struct mt352_config digitv_mt352_config = {
+        .demod_init = digitv_mt352_demod_init,
+};
+
+static int digitv_nxt6000_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        u8 b[5];
+
+        fe->ops.tuner_ops.calc_regs(fe, fep, b, sizeof(b));
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
+        return digitv_ctrl_msg(adap->dev, USB_WRITE_TUNER, 0, &b[1], 4, NULL, 0);
+}
+
+static struct nxt6000_config digitv_nxt6000_config = {
+        .clock_inversion = 1,
+};
+
+static int digitv_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct digitv_state *st = adap->dev->priv;
+
+        if ((adap->fe = dvb_attach(mt352_attach, &digitv_mt352_config, &adap->dev->i2c_adap)) != NULL) {
+                st->is_nxt6000 = 0;
+                return 0;
+        }
+        if ((adap->fe = dvb_attach(nxt6000_attach, &digitv_nxt6000_config, &adap->dev->i2c_adap)) != NULL) {
+                st->is_nxt6000 = 1;
+                return 0;
+        }
+        return -EIO;
+}
+
+static int digitv_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct digitv_state *st = adap->dev->priv;
+
+        if (!dvb_attach(dvb_pll_attach, adap->fe, 0x60, NULL, DVB_PLL_TDED4))
+                return -ENODEV;
+
+        if (st->is_nxt6000)
+                adap->fe->ops.tuner_ops.set_params = digitv_nxt6000_tuner_set_params;
+
+        return 0;
+}
+
+static struct rc_map_table rc_map_digitv_table[] = {
+        { 0x5f55, KEY_0 },
+        { 0x6f55, KEY_1 },
+        { 0x9f55, KEY_2 },
+        { 0xaf55, KEY_3 },
+        { 0x5f56, KEY_4 },
+        { 0x6f56, KEY_5 },
+        { 0x9f56, KEY_6 },
+        { 0xaf56, KEY_7 },
+        { 0x5f59, KEY_8 },
+        { 0x6f59, KEY_9 },
+        { 0x9f59, KEY_TV },
+        { 0xaf59, KEY_AUX },
+        { 0x5f5a, KEY_DVD },
+        { 0x6f5a, KEY_POWER },
+        { 0x9f5a, KEY_CAMERA },     /* labelled 'Picture' */
+        { 0xaf5a, KEY_AUDIO },
+        { 0x5f65, KEY_INFO },
+        { 0x6f65, KEY_F13 },     /* 16:9 */
+        { 0x9f65, KEY_F14 },     /* 14:9 */
+        { 0xaf65, KEY_EPG },
+        { 0x5f66, KEY_EXIT },
+        { 0x6f66, KEY_MENU },
+        { 0x9f66, KEY_UP },
+        { 0xaf66, KEY_DOWN },
+        { 0x5f69, KEY_LEFT },
+        { 0x6f69, KEY_RIGHT },
+        { 0x9f69, KEY_ENTER },
+        { 0xaf69, KEY_CHANNELUP },
+        { 0x5f6a, KEY_CHANNELDOWN },
+        { 0x6f6a, KEY_VOLUMEUP },
+        { 0x9f6a, KEY_VOLUMEDOWN },
+        { 0xaf6a, KEY_RED },
+        { 0x5f95, KEY_GREEN },
+        { 0x6f95, KEY_YELLOW },
+        { 0x9f95, KEY_BLUE },
+        { 0xaf95, KEY_SUBTITLE },
+        { 0x5f96, KEY_F15 },     /* AD */
+        { 0x6f96, KEY_TEXT },
+        { 0x9f96, KEY_MUTE },
+        { 0xaf96, KEY_REWIND },
+        { 0x5f99, KEY_STOP },
+        { 0x6f99, KEY_PLAY },
+        { 0x9f99, KEY_FASTFORWARD },
+        { 0xaf99, KEY_F16 },     /* chapter */
+        { 0x5f9a, KEY_PAUSE },
+        { 0x6f9a, KEY_PLAY },
+        { 0x9f9a, KEY_RECORD },
+        { 0xaf9a, KEY_F17 },     /* picture in picture */
+        { 0x5fa5, KEY_KPPLUS },  /* zoom in */
+        { 0x6fa5, KEY_KPMINUS }, /* zoom out */
+        { 0x9fa5, KEY_F18 },     /* capture */
+        { 0xafa5, KEY_F19 },     /* web */
+        { 0x5fa6, KEY_EMAIL },
+        { 0x6fa6, KEY_PHONE },
+        { 0x9fa6, KEY_PC },
+};
+
+static int digitv_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        int i;
+        u8 key[5];
+        u8 b[4] = { 0 };
+
+        *event = 0;
+        *state = REMOTE_NO_KEY_PRESSED;
+
+        digitv_ctrl_msg(d,USB_READ_REMOTE,0,NULL,0,&key[1],4);
+
+        /* Tell the device we've read the remote. Not sure how necessary
+           this is, but the Nebula SDK does it. */
+        digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0);
+
+        /* if something is inside the buffer, simulate key press */
+        if (key[1] != 0)
+        {
+                  for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
+                        if (rc5_custom(&d->props.rc.legacy.rc_map_table[i]) == key[1] &&
+                            rc5_data(&d->props.rc.legacy.rc_map_table[i]) == key[2]) {
+                                *event = d->props.rc.legacy.rc_map_table[i].keycode;
+                                *state = REMOTE_KEY_PRESSED;
+                                return 0;
+                        }
+                }
+        }
+
+        if (key[0] != 0)
+                deb_rc("key: %x %x %x %x %x\n",key[0],key[1],key[2],key[3],key[4]);
+        return 0;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties digitv_properties;
+
+static int digitv_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        struct dvb_usb_device *d;
+        int ret = dvb_usb_device_init(intf, &digitv_properties, THIS_MODULE, &d,
+                                      adapter_nr);
+        if (ret == 0) {
+                u8 b[4] = { 0 };
+
+                if (d != NULL) { /* do that only when the firmware is loaded */
+                        b[0] = 1;
+                        digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0);
+
+                        b[0] = 0;
+                        digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0);
+                }
+        }
+        return ret;
+}
+
+static struct usb_device_id digitv_table [] = {
+                { USB_DEVICE(USB_VID_ANCHOR, USB_PID_NEBULA_DIGITV) },
+                { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, digitv_table);
+
+static struct dvb_usb_device_properties digitv_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-digitv-02.fw",
+
+        .size_of_priv = sizeof(struct digitv_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .frontend_attach  = digitv_frontend_attach,
+                        .tuner_attach     = digitv_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+        .identify_state   = digitv_identify_state,
+
+        .rc.legacy = {
+                .rc_interval      = 1000,
+                .rc_map_table     = rc_map_digitv_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_digitv_table),
+                .rc_query         = digitv_rc_query,
+        },
+
+        .i2c_algo         = &digitv_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "Nebula Electronics uDigiTV DVB-T USB2.0)",
+                        { &digitv_table[0], NULL },
+                        { NULL },
+                },
+                { NULL },
+        }
+};
+
+static struct usb_driver digitv_driver = {
+        .name           = "dvb_usb_digitv",
+        .probe          = digitv_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = digitv_table,
+};
+
+/* module stuff */
+static int __init digitv_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&digitv_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit digitv_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&digitv_driver);
+}
+
+module_init (digitv_module_init);
+module_exit (digitv_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for Nebula Electronics uDigiTV DVB-T USB2.0");
+MODULE_VERSION("1.0-alpha");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/digitv.h b/drivers/media/dvb/dvb-usb/digitv.h
new file mode 100644
index 00000000000..908c09f4966
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/digitv.h
@@ -0,0 +1,66 @@
+#ifndef _DVB_USB_DIGITV_H_
+#define _DVB_USB_DIGITV_H_
+
+#define DVB_USB_LOG_PREFIX "digitv"
+#include "dvb-usb.h"
+
+struct digitv_state {
+    int is_nxt6000;
+};
+
+/* protocol (from usblogging and the SDK:
+ *
+ * Always 7 bytes bulk message(s) for controlling
+ *
+ * First byte describes the command. Reads are 2 consecutive transfer (as always).
+ *
+ * General structure:
+ *
+ * write or first message of a read:
+ * <cmdbyte> VV <len> B0 B1 B2 B3
+ *
+ * second message of a read
+ * <cmdbyte> VV <len> R0 R1 R2 R3
+ *
+ * whereas 0 < len <= 4
+ *
+ * I2C address is stored somewhere inside the device.
+ *
+ * 0x01 read from EEPROM
+ *  VV = offset; B* = 0; R* = value(s)
+ *
+ * 0x02 read register of the COFDM
+ *  VV = register; B* = 0; R* = value(s)
+ *
+ * 0x05 write register of the COFDM
+ *  VV = register; B* = value(s);
+ *
+ * 0x06 write to the tuner (only for NXT6000)
+ *  VV = 0; B* = PLL data; len = 4;
+ *
+ * 0x03 read remote control
+ *  VV = 0; B* = 0; len = 4; R* = key
+ *
+ * 0x07 write to the remote (don't know why one should this, resetting ?)
+ *  VV = 0; B* = key; len = 4;
+ *
+ * 0x08 write remote type
+ *  VV = 0; B[0] = 0x01, len = 4
+ *
+ * 0x09 write device init
+ *  TODO
+ */
+#define USB_READ_EEPROM         1
+
+#define USB_READ_COFDM          2
+#define USB_WRITE_COFDM         5
+
+#define USB_WRITE_TUNER         6
+
+#define USB_READ_REMOTE         3
+#define USB_WRITE_REMOTE        7
+#define USB_WRITE_REMOTE_TYPE   8
+
+#define USB_DEV_INIT            9
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dtt200u-fe.c b/drivers/media/dvb/dvb-usb/dtt200u-fe.c
new file mode 100644
index 00000000000..17413adec7a
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dtt200u-fe.c
@@ -0,0 +1,205 @@
+/* Frontend part of the Linux driver for the WideView/ Yakumo/ Hama/
+ * Typhoon/ Yuan DVB-T USB2.0 receiver.
+ *
+ * Copyright (C) 2005 Patrick Boettcher <patrick.boettcher@desy.de>
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dtt200u.h"
+
+struct dtt200u_fe_state {
+        struct dvb_usb_device *d;
+
+        fe_status_t stat;
+
+        struct dvb_frontend_parameters fep;
+        struct dvb_frontend frontend;
+};
+
+static int dtt200u_fe_read_status(struct dvb_frontend* fe, fe_status_t *stat)
+{
+        struct dtt200u_fe_state *state = fe->demodulator_priv;
+        u8 st = GET_TUNE_STATUS, b[3];
+
+        dvb_usb_generic_rw(state->d,&st,1,b,3,0);
+
+        switch (b[0]) {
+                case 0x01:
+                        *stat = FE_HAS_SIGNAL | FE_HAS_CARRIER |
+                                FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
+                        break;
+                case 0x00: /* pending */
+                        *stat = FE_TIMEDOUT; /* during set_frontend */
+                        break;
+                default:
+                case 0x02: /* failed */
+                        *stat = 0;
+                        break;
+        }
+        return 0;
+}
+
+static int dtt200u_fe_read_ber(struct dvb_frontend* fe, u32 *ber)
+{
+        struct dtt200u_fe_state *state = fe->demodulator_priv;
+        u8 bw = GET_VIT_ERR_CNT,b[3];
+        dvb_usb_generic_rw(state->d,&bw,1,b,3,0);
+        *ber = (b[0] << 16) | (b[1] << 8) | b[2];
+        return 0;
+}
+
+static int dtt200u_fe_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
+{
+        struct dtt200u_fe_state *state = fe->demodulator_priv;
+        u8 bw = GET_RS_UNCOR_BLK_CNT,b[2];
+
+        dvb_usb_generic_rw(state->d,&bw,1,b,2,0);
+        *unc = (b[0] << 8) | b[1];
+        return 0;
+}
+
+static int dtt200u_fe_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
+{
+        struct dtt200u_fe_state *state = fe->demodulator_priv;
+        u8 bw = GET_AGC, b;
+        dvb_usb_generic_rw(state->d,&bw,1,&b,1,0);
+        *strength = (b << 8) | b;
+        return 0;
+}
+
+static int dtt200u_fe_read_snr(struct dvb_frontend* fe, u16 *snr)
+{
+        struct dtt200u_fe_state *state = fe->demodulator_priv;
+        u8 bw = GET_SNR,br;
+        dvb_usb_generic_rw(state->d,&bw,1,&br,1,0);
+        *snr = ~((br << 8) | br);
+        return 0;
+}
+
+static int dtt200u_fe_init(struct dvb_frontend* fe)
+{
+        struct dtt200u_fe_state *state = fe->demodulator_priv;
+        u8 b = SET_INIT;
+        return dvb_usb_generic_write(state->d,&b,1);
+}
+
+static int dtt200u_fe_sleep(struct dvb_frontend* fe)
+{
+        return dtt200u_fe_init(fe);
+}
+
+static int dtt200u_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 1500;
+        tune->step_size = 0;
+        tune->max_drift = 0;
+        return 0;
+}
+
+static int dtt200u_fe_set_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct dtt200u_fe_state *state = fe->demodulator_priv;
+        int i;
+        fe_status_t st;
+        u16 freq = fep->frequency / 250000;
+        u8 bwbuf[2] = { SET_BANDWIDTH, 0 },freqbuf[3] = { SET_RF_FREQ, 0, 0 };
+
+        switch (fep->u.ofdm.bandwidth) {
+                case BANDWIDTH_8_MHZ: bwbuf[1] = 8; break;
+                case BANDWIDTH_7_MHZ: bwbuf[1] = 7; break;
+                case BANDWIDTH_6_MHZ: bwbuf[1] = 6; break;
+                case BANDWIDTH_AUTO: return -EOPNOTSUPP;
+                default:
+                        return -EINVAL;
+        }
+
+        dvb_usb_generic_write(state->d,bwbuf,2);
+
+        freqbuf[1] = freq & 0xff;
+        freqbuf[2] = (freq >> 8) & 0xff;
+        dvb_usb_generic_write(state->d,freqbuf,3);
+
+        for (i = 0; i < 30; i++) {
+                msleep(20);
+                dtt200u_fe_read_status(fe, &st);
+                if (st & FE_TIMEDOUT)
+                        continue;
+        }
+
+        return 0;
+}
+
+static int dtt200u_fe_get_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct dtt200u_fe_state *state = fe->demodulator_priv;
+        memcpy(fep,&state->fep,sizeof(struct dvb_frontend_parameters));
+        return 0;
+}
+
+static void dtt200u_fe_release(struct dvb_frontend* fe)
+{
+        struct dtt200u_fe_state *state = (struct dtt200u_fe_state*) fe->demodulator_priv;
+        kfree(state);
+}
+
+static struct dvb_frontend_ops dtt200u_fe_ops;
+
+struct dvb_frontend* dtt200u_fe_attach(struct dvb_usb_device *d)
+{
+        struct dtt200u_fe_state* state = NULL;
+
+        /* allocate memory for the internal state */
+        state = kzalloc(sizeof(struct dtt200u_fe_state), GFP_KERNEL);
+        if (state == NULL)
+                goto error;
+
+        deb_info("attaching frontend dtt200u\n");
+
+        state->d = d;
+
+        memcpy(&state->frontend.ops,&dtt200u_fe_ops,sizeof(struct dvb_frontend_ops));
+        state->frontend.demodulator_priv = state;
+
+        return &state->frontend;
+error:
+        return NULL;
+}
+
+static struct dvb_frontend_ops dtt200u_fe_ops = {
+        .info = {
+                .name                   = "WideView USB DVB-T",
+                .type                   = FE_OFDM,
+                .frequency_min          = 44250000,
+                .frequency_max          = 867250000,
+                .frequency_stepsize     = 250000,
+                .caps = FE_CAN_INVERSION_AUTO |
+                                FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                                FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
+                                FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
+                                FE_CAN_TRANSMISSION_MODE_AUTO |
+                                FE_CAN_GUARD_INTERVAL_AUTO |
+                                FE_CAN_RECOVER |
+                                FE_CAN_HIERARCHY_AUTO,
+        },
+
+        .release = dtt200u_fe_release,
+
+        .init = dtt200u_fe_init,
+        .sleep = dtt200u_fe_sleep,
+
+        .set_frontend = dtt200u_fe_set_frontend,
+        .get_frontend = dtt200u_fe_get_frontend,
+        .get_tune_settings = dtt200u_fe_get_tune_settings,
+
+        .read_status = dtt200u_fe_read_status,
+        .read_ber = dtt200u_fe_read_ber,
+        .read_signal_strength = dtt200u_fe_read_signal_strength,
+        .read_snr = dtt200u_fe_read_snr,
+        .read_ucblocks = dtt200u_fe_read_unc_blocks,
+};
diff --git a/drivers/media/dvb/dvb-usb/dtt200u.c b/drivers/media/dvb/dvb-usb/dtt200u.c
new file mode 100644
index 00000000000..ecd86eca254
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dtt200u.c
@@ -0,0 +1,375 @@
+/* DVB USB library compliant Linux driver for the WideView/ Yakumo/ Hama/
+ * Typhoon/ Yuan/ Miglia DVB-T USB2.0 receiver.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ * Thanks to Steve Chang from WideView for providing support for the WT-220U.
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dtt200u.h"
+
+/* debug */
+int dvb_usb_dtt200u_debug;
+module_param_named(debug,dvb_usb_dtt200u_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2 (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int dtt200u_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 b = SET_INIT;
+
+        if (onoff)
+                dvb_usb_generic_write(d,&b,2);
+
+        return 0;
+}
+
+static int dtt200u_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        u8 b_streaming[2] = { SET_STREAMING, onoff };
+        u8 b_rst_pid = RESET_PID_FILTER;
+
+        dvb_usb_generic_write(adap->dev, b_streaming, 2);
+
+        if (onoff == 0)
+                dvb_usb_generic_write(adap->dev, &b_rst_pid, 1);
+        return 0;
+}
+
+static int dtt200u_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff)
+{
+        u8 b_pid[4];
+        pid = onoff ? pid : 0;
+
+        b_pid[0] = SET_PID_FILTER;
+        b_pid[1] = index;
+        b_pid[2] = pid & 0xff;
+        b_pid[3] = (pid >> 8) & 0x1f;
+
+        return dvb_usb_generic_write(adap->dev, b_pid, 4);
+}
+
+/* remote control */
+/* key list for the tiny remote control (Yakumo, don't know about the others) */
+static struct rc_map_table rc_map_dtt200u_table[] = {
+        { 0x8001, KEY_MUTE },
+        { 0x8002, KEY_CHANNELDOWN },
+        { 0x8003, KEY_VOLUMEDOWN },
+        { 0x8004, KEY_1 },
+        { 0x8005, KEY_2 },
+        { 0x8006, KEY_3 },
+        { 0x8007, KEY_4 },
+        { 0x8008, KEY_5 },
+        { 0x8009, KEY_6 },
+        { 0x800a, KEY_7 },
+        { 0x800c, KEY_ZOOM },
+        { 0x800d, KEY_0 },
+        { 0x800e, KEY_SELECT },
+        { 0x8012, KEY_POWER },
+        { 0x801a, KEY_CHANNELUP },
+        { 0x801b, KEY_8 },
+        { 0x801e, KEY_VOLUMEUP },
+        { 0x801f, KEY_9 },
+};
+
+static int dtt200u_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        u8 key[5],cmd = GET_RC_CODE;
+        dvb_usb_generic_rw(d,&cmd,1,key,5,0);
+        dvb_usb_nec_rc_key_to_event(d,key,event,state);
+        if (key[0] != 0)
+                deb_info("key: %x %x %x %x %x\n",key[0],key[1],key[2],key[3],key[4]);
+        return 0;
+}
+
+static int dtt200u_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        adap->fe = dtt200u_fe_attach(adap->dev);
+        return 0;
+}
+
+static struct dvb_usb_device_properties dtt200u_properties;
+static struct dvb_usb_device_properties wt220u_fc_properties;
+static struct dvb_usb_device_properties wt220u_properties;
+static struct dvb_usb_device_properties wt220u_zl0353_properties;
+static struct dvb_usb_device_properties wt220u_miglia_properties;
+
+static int dtt200u_usb_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        if (0 == dvb_usb_device_init(intf, &dtt200u_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &wt220u_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &wt220u_fc_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &wt220u_zl0353_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &wt220u_miglia_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
+                return 0;
+
+        return -ENODEV;
+}
+
+static struct usb_device_id dtt200u_usb_table [] = {
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_DTT200U_COLD) },
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_DTT200U_WARM) },
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_COLD)  },
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_WARM)  },
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_ZL0353_COLD)  },
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_ZL0353_WARM)  },
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_FC_COLD)  },
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_FC_WARM)  },
+        { USB_DEVICE(USB_VID_WIDEVIEW, USB_PID_WT220U_ZAP250_COLD)  },
+        { USB_DEVICE(USB_VID_MIGLIA, USB_PID_WT220U_ZAP250_COLD)  },
+        { 0 },
+};
+MODULE_DEVICE_TABLE(usb, dtt200u_usb_table);
+
+static struct dvb_usb_device_properties dtt200u_properties = {
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-dtt200u-01.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING,
+                        .pid_filter_count = 15,
+
+        .streaming_ctrl  = dtt200u_streaming_ctrl,
+        .pid_filter      = dtt200u_pid_filter,
+        .frontend_attach = dtt200u_frontend_attach,
+        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                .count = 7,
+                .endpoint = 0x02,
+                .u = {
+                        .bulk = {
+                                .buffersize = 4096,
+                        }
+                }
+        },
+                }
+        },
+        .power_ctrl      = dtt200u_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval     = 300,
+                .rc_map_table    = rc_map_dtt200u_table,
+                .rc_map_size     = ARRAY_SIZE(rc_map_dtt200u_table),
+                .rc_query        = dtt200u_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                { .name = "WideView/Yuan/Yakumo/Hama/Typhoon DVB-T USB2.0 (WT-200U)",
+                  .cold_ids = { &dtt200u_usb_table[0], NULL },
+                  .warm_ids = { &dtt200u_usb_table[1], NULL },
+                },
+                { NULL },
+        }
+};
+
+static struct dvb_usb_device_properties wt220u_properties = {
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-wt220u-02.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING,
+                        .pid_filter_count = 15,
+
+        .streaming_ctrl  = dtt200u_streaming_ctrl,
+        .pid_filter      = dtt200u_pid_filter,
+        .frontend_attach = dtt200u_frontend_attach,
+        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                .count = 7,
+                .endpoint = 0x02,
+                .u = {
+                        .bulk = {
+                                .buffersize = 4096,
+                        }
+                }
+        },
+                }
+        },
+        .power_ctrl      = dtt200u_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval     = 300,
+                .rc_map_table      = rc_map_dtt200u_table,
+                .rc_map_size = ARRAY_SIZE(rc_map_dtt200u_table),
+                .rc_query        = dtt200u_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                { .name = "WideView WT-220U PenType Receiver (Typhoon/Freecom)",
+                  .cold_ids = { &dtt200u_usb_table[2], &dtt200u_usb_table[8], NULL },
+                  .warm_ids = { &dtt200u_usb_table[3], NULL },
+                },
+                { NULL },
+        }
+};
+
+static struct dvb_usb_device_properties wt220u_fc_properties = {
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-wt220u-fc03.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING,
+                        .pid_filter_count = 15,
+
+        .streaming_ctrl  = dtt200u_streaming_ctrl,
+        .pid_filter      = dtt200u_pid_filter,
+        .frontend_attach = dtt200u_frontend_attach,
+        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                .count = 7,
+                                .endpoint = 0x06,
+                .u = {
+                        .bulk = {
+                                .buffersize = 4096,
+                        }
+                }
+        },
+                }
+        },
+        .power_ctrl      = dtt200u_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval     = 300,
+                .rc_map_table    = rc_map_dtt200u_table,
+                .rc_map_size     = ARRAY_SIZE(rc_map_dtt200u_table),
+                .rc_query        = dtt200u_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                { .name = "WideView WT-220U PenType Receiver (Typhoon/Freecom)",
+                  .cold_ids = { &dtt200u_usb_table[6], NULL },
+                  .warm_ids = { &dtt200u_usb_table[7], NULL },
+                },
+                { NULL },
+        }
+};
+
+static struct dvb_usb_device_properties wt220u_zl0353_properties = {
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-wt220u-zl0353-01.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING,
+                        .pid_filter_count = 15,
+
+                        .streaming_ctrl  = dtt200u_streaming_ctrl,
+                        .pid_filter      = dtt200u_pid_filter,
+                        .frontend_attach = dtt200u_frontend_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+        .power_ctrl      = dtt200u_power_ctrl,
+
+        .rc.legacy = {
+                .rc_interval     = 300,
+                .rc_map_table    = rc_map_dtt200u_table,
+                .rc_map_size     = ARRAY_SIZE(rc_map_dtt200u_table),
+                .rc_query        = dtt200u_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                { .name = "WideView WT-220U PenType Receiver (based on ZL353)",
+                  .cold_ids = { &dtt200u_usb_table[4], NULL },
+                  .warm_ids = { &dtt200u_usb_table[5], NULL },
+                },
+                { NULL },
+        }
+};
+
+static struct dvb_usb_device_properties wt220u_miglia_properties = {
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-wt220u-miglia-01.fw",
+
+        .num_adapters = 1,
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                { .name = "WideView WT-220U PenType Receiver (Miglia)",
+                  .cold_ids = { &dtt200u_usb_table[9], NULL },
+                  /* This device turns into WT220U_ZL0353_WARM when fw
+                     has been uploaded */
+                  .warm_ids = { NULL },
+                },
+                { NULL },
+        }
+};
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver dtt200u_usb_driver = {
+        .name           = "dvb_usb_dtt200u",
+        .probe          = dtt200u_usb_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = dtt200u_usb_table,
+};
+
+/* module stuff */
+static int __init dtt200u_usb_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&dtt200u_usb_driver))) {
+                err("usb_register failed. (%d)",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit dtt200u_usb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&dtt200u_usb_driver);
+}
+
+module_init(dtt200u_usb_module_init);
+module_exit(dtt200u_usb_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for the WideView/Yakumo/Hama/Typhoon/Club3D/Miglia DVB-T USB2.0 devices");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/dtt200u.h b/drivers/media/dvb/dvb-usb/dtt200u.h
new file mode 100644
index 00000000000..005b0a7df35
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dtt200u.h
@@ -0,0 +1,57 @@
+/* Common header file of Linux driver for the WideView/ Yakumo/ Hama/
+ * Typhoon/ Yuan DVB-T USB2.0 receiver.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_DTT200U_H_
+#define _DVB_USB_DTT200U_H_
+
+#define DVB_USB_LOG_PREFIX "dtt200u"
+
+#include "dvb-usb.h"
+
+extern int dvb_usb_dtt200u_debug;
+#define deb_info(args...) dprintk(dvb_usb_dtt200u_debug,0x01,args)
+#define deb_xfer(args...) dprintk(dvb_usb_dtt200u_debug,0x02,args)
+
+/* guessed protocol description (reverse engineered):
+ * read
+ *  00 - USB type 0x02 for usb2.0, 0x01 for usb1.1
+ *  88 - locking 2 bytes (0x80 0x40 == no signal, 0x89 0x20 == nice signal)
+ */
+
+#define GET_SPEED               0x00
+#define GET_TUNE_STATUS         0x81
+#define GET_RC_CODE             0x84
+#define GET_CONFIGURATION       0x88
+#define GET_AGC                 0x89
+#define GET_SNR                 0x8a
+#define GET_VIT_ERR_CNT         0x8c
+#define GET_RS_ERR_CNT          0x8d
+#define GET_RS_UNCOR_BLK_CNT    0x8e
+
+/* write
+ *  01 - init
+ *  02 - frequency (divided by 250000)
+ *  03 - bandwidth
+ *  04 - pid table (index pid(7:0) pid(12:8))
+ *  05 - reset the pid table
+ *  08 - transfer switch
+ */
+
+#define SET_INIT                0x01
+#define SET_RF_FREQ             0x02
+#define SET_BANDWIDTH           0x03
+#define SET_PID_FILTER          0x04
+#define RESET_PID_FILTER        0x05
+#define SET_STREAMING           0x08
+
+extern struct dvb_frontend * dtt200u_fe_attach(struct dvb_usb_device *d);
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dtv5100.c b/drivers/media/dvb/dvb-usb/dtv5100.c
new file mode 100644
index 00000000000..078ce92ca43
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dtv5100.c
@@ -0,0 +1,240 @@
+/*
+ * DVB USB Linux driver for AME DTV-5100 USB2.0 DVB-T
+ *
+ * Copyright (C) 2008  Antoine Jacquet <royale@zerezo.com>
+ * http://royale.zerezo.com/dtv5100/
+ *
+ * Inspired by gl861.c and au6610.c drivers
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "dtv5100.h"
+#include "zl10353.h"
+#include "qt1010.h"
+
+/* debug */
+static int dvb_usb_dtv5100_debug;
+module_param_named(debug, dvb_usb_dtv5100_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int dtv5100_i2c_msg(struct dvb_usb_device *d, u8 addr,
+                           u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        u8 request;
+        u8 type;
+        u16 value;
+        u16 index;
+
+        switch (wlen) {
+        case 1:
+                /* write { reg }, read { value } */
+                request = (addr == DTV5100_DEMOD_ADDR ? DTV5100_DEMOD_READ :
+                                                        DTV5100_TUNER_READ);
+                type = USB_TYPE_VENDOR | USB_DIR_IN;
+                value = 0;
+                break;
+        case 2:
+                /* write { reg, value } */
+                request = (addr == DTV5100_DEMOD_ADDR ? DTV5100_DEMOD_WRITE :
+                                                        DTV5100_TUNER_WRITE);
+                type = USB_TYPE_VENDOR | USB_DIR_OUT;
+                value = wbuf[1];
+                break;
+        default:
+                warn("wlen = %x, aborting.", wlen);
+                return -EINVAL;
+        }
+        index = (addr << 8) + wbuf[0];
+
+        msleep(1); /* avoid I2C errors */
+        return usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0), request,
+                               type, value, index, rbuf, rlen,
+                               DTV5100_USB_TIMEOUT);
+}
+
+/* I2C */
+static int dtv5100_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                            int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i;
+
+        if (num > 2)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                /* write/read request */
+                if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
+                        if (dtv5100_i2c_msg(d, msg[i].addr, msg[i].buf,
+                                            msg[i].len, msg[i+1].buf,
+                                            msg[i+1].len) < 0)
+                                break;
+                        i++;
+                } else if (dtv5100_i2c_msg(d, msg[i].addr, msg[i].buf,
+                                           msg[i].len, NULL, 0) < 0)
+                                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+static u32 dtv5100_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm dtv5100_i2c_algo = {
+        .master_xfer   = dtv5100_i2c_xfer,
+        .functionality = dtv5100_i2c_func,
+};
+
+/* Callbacks for DVB USB */
+static struct zl10353_config dtv5100_zl10353_config = {
+        .demod_address = DTV5100_DEMOD_ADDR,
+        .no_tuner = 1,
+        .parallel_ts = 1,
+};
+
+static int dtv5100_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        adap->fe = dvb_attach(zl10353_attach, &dtv5100_zl10353_config,
+                              &adap->dev->i2c_adap);
+        if (adap->fe == NULL)
+                return -EIO;
+
+        /* disable i2c gate, or it won't work... is this safe? */
+        adap->fe->ops.i2c_gate_ctrl = NULL;
+
+        return 0;
+}
+
+static struct qt1010_config dtv5100_qt1010_config = {
+        .i2c_address = DTV5100_TUNER_ADDR
+};
+
+static int dtv5100_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        return dvb_attach(qt1010_attach,
+                          adap->fe, &adap->dev->i2c_adap,
+                          &dtv5100_qt1010_config) == NULL ? -ENODEV : 0;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties dtv5100_properties;
+
+static int dtv5100_probe(struct usb_interface *intf,
+                         const struct usb_device_id *id)
+{
+        int i, ret;
+        struct usb_device *udev = interface_to_usbdev(intf);
+
+        /* initialize non qt1010/zl10353 part? */
+        for (i = 0; dtv5100_init[i].request; i++) {
+                ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                                      dtv5100_init[i].request,
+                                      USB_TYPE_VENDOR | USB_DIR_OUT,
+                                      dtv5100_init[i].value,
+                                      dtv5100_init[i].index, NULL, 0,
+                                      DTV5100_USB_TIMEOUT);
+                if (ret)
+                        return ret;
+        }
+
+        ret = dvb_usb_device_init(intf, &dtv5100_properties,
+                                  THIS_MODULE, NULL, adapter_nr);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct usb_device_id dtv5100_table[] = {
+        { USB_DEVICE(0x06be, 0xa232) },
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, dtv5100_table);
+
+static struct dvb_usb_device_properties dtv5100_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+
+        .size_of_priv = 0,
+
+        .num_adapters = 1,
+        .adapter = {{
+                .frontend_attach = dtv5100_frontend_attach,
+                .tuner_attach    = dtv5100_tuner_attach,
+
+                .stream = {
+                        .type = USB_BULK,
+                        .count = 8,
+                        .endpoint = 0x82,
+                        .u = {
+                                .bulk = {
+                                        .buffersize = 4096,
+                                }
+                        }
+                },
+        } },
+
+        .i2c_algo = &dtv5100_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        .name = "AME DTV-5100 USB2.0 DVB-T",
+                        .cold_ids = { NULL },
+                        .warm_ids = { &dtv5100_table[0], NULL },
+                },
+        }
+};
+
+static struct usb_driver dtv5100_driver = {
+        .name           = "dvb_usb_dtv5100",
+        .probe          = dtv5100_probe,
+        .disconnect     = dvb_usb_device_exit,
+        .id_table       = dtv5100_table,
+};
+
+/* module stuff */
+static int __init dtv5100_module_init(void)
+{
+        int ret;
+
+        ret = usb_register(&dtv5100_driver);
+        if (ret)
+                err("usb_register failed. Error number %d", ret);
+
+        return ret;
+}
+
+static void __exit dtv5100_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&dtv5100_driver);
+}
+
+module_init(dtv5100_module_init);
+module_exit(dtv5100_module_exit);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/dtv5100.h b/drivers/media/dvb/dvb-usb/dtv5100.h
new file mode 100644
index 00000000000..93e96e04a82
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dtv5100.h
@@ -0,0 +1,51 @@
+/*
+ * DVB USB Linux driver for AME DTV-5100 USB2.0 DVB-T
+ *
+ * Copyright (C) 2008  Antoine Jacquet <royale@zerezo.com>
+ * http://royale.zerezo.com/dtv5100/
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _DVB_USB_DTV5100_H_
+#define _DVB_USB_DTV5100_H_
+
+#define DVB_USB_LOG_PREFIX "dtv5100"
+#include "dvb-usb.h"
+
+#define DTV5100_USB_TIMEOUT 500
+
+#define DTV5100_DEMOD_ADDR      0x00
+#define DTV5100_DEMOD_WRITE     0xc0
+#define DTV5100_DEMOD_READ      0xc1
+
+#define DTV5100_TUNER_ADDR      0xc4
+#define DTV5100_TUNER_WRITE     0xc7
+#define DTV5100_TUNER_READ      0xc8
+
+#define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
+#define DRIVER_DESC "AME DTV-5100 USB2.0 DVB-T"
+
+static struct {
+        u8 request;
+        u8 value;
+        u16 index;
+} dtv5100_init[] = {
+        { 0x000000c5, 0x00000000, 0x00000001 },
+        { 0x000000c5, 0x00000001, 0x00000001 },
+        { }             /* Terminating entry */
+};
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-common.h b/drivers/media/dvb/dvb-usb/dvb-usb-common.h
new file mode 100644
index 00000000000..6b7b2a89242
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-common.h
@@ -0,0 +1,52 @@
+/* dvb-usb-common.h is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ * see dvb-usb-init.c for copyright information.
+ *
+ * a header file containing prototypes and types for internal use of the dvb-usb-lib
+ */
+#ifndef _DVB_USB_COMMON_H_
+#define _DVB_USB_COMMON_H_
+
+#define DVB_USB_LOG_PREFIX "dvb-usb"
+#include "dvb-usb.h"
+
+extern int dvb_usb_debug;
+extern int dvb_usb_disable_rc_polling;
+
+#define deb_info(args...)  dprintk(dvb_usb_debug,0x001,args)
+#define deb_xfer(args...)  dprintk(dvb_usb_debug,0x002,args)
+#define deb_pll(args...)   dprintk(dvb_usb_debug,0x004,args)
+#define deb_ts(args...)    dprintk(dvb_usb_debug,0x008,args)
+#define deb_err(args...)   dprintk(dvb_usb_debug,0x010,args)
+#define deb_rc(args...)    dprintk(dvb_usb_debug,0x020,args)
+#define deb_fw(args...)    dprintk(dvb_usb_debug,0x040,args)
+#define deb_mem(args...)   dprintk(dvb_usb_debug,0x080,args)
+#define deb_uxfer(args...) dprintk(dvb_usb_debug,0x100,args)
+
+/* commonly used  methods */
+extern int dvb_usb_download_firmware(struct usb_device *, struct dvb_usb_device_properties *);
+
+extern int dvb_usb_device_power_ctrl(struct dvb_usb_device *d, int onoff);
+
+extern int usb_urb_init(struct usb_data_stream *stream, struct usb_data_stream_properties *props);
+extern int usb_urb_exit(struct usb_data_stream *stream);
+extern int usb_urb_submit(struct usb_data_stream *stream);
+extern int usb_urb_kill(struct usb_data_stream *stream);
+
+extern int dvb_usb_adapter_stream_init(struct dvb_usb_adapter *adap);
+extern int dvb_usb_adapter_stream_exit(struct dvb_usb_adapter *adap);
+
+extern int dvb_usb_i2c_init(struct dvb_usb_device *);
+extern int dvb_usb_i2c_exit(struct dvb_usb_device *);
+
+extern int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap,
+                                    short *adapter_nums);
+extern int dvb_usb_adapter_dvb_exit(struct dvb_usb_adapter *adap);
+extern int dvb_usb_adapter_frontend_init(struct dvb_usb_adapter *adap);
+extern int dvb_usb_adapter_frontend_exit(struct dvb_usb_adapter *adap);
+
+extern int dvb_usb_remote_init(struct dvb_usb_device *);
+extern int dvb_usb_remote_exit(struct dvb_usb_device *);
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c b/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c
new file mode 100644
index 00000000000..b3cb626ed56
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c
@@ -0,0 +1,216 @@
+/* dvb-usb-dvb.c is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
+ * see dvb-usb-init.c for copyright information.
+ *
+ * This file contains functions for initializing and handling the
+ * linux-dvb API.
+ */
+#include "dvb-usb-common.h"
+
+/* does the complete input transfer handling */
+static int dvb_usb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed, int onoff)
+{
+        struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv;
+        int newfeedcount, ret;
+
+        if (adap == NULL)
+                return -ENODEV;
+
+        newfeedcount = adap->feedcount + (onoff ? 1 : -1);
+
+        /* stop feed before setting a new pid if there will be no pid anymore */
+        if (newfeedcount == 0) {
+                deb_ts("stop feeding\n");
+                usb_urb_kill(&adap->stream);
+
+                if (adap->props.streaming_ctrl != NULL) {
+                        ret = adap->props.streaming_ctrl(adap, 0);
+                        if (ret < 0) {
+                                err("error while stopping stream.");
+                                return ret;
+                        }
+                }
+        }
+
+        adap->feedcount = newfeedcount;
+
+        /* activate the pid on the device specific pid_filter */
+        deb_ts("setting pid (%s): %5d %04x at index %d '%s'\n",adap->pid_filtering ?
+                "yes" : "no", dvbdmxfeed->pid,dvbdmxfeed->pid,dvbdmxfeed->index,onoff ?
+                "on" : "off");
+        if (adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER &&
+                adap->pid_filtering &&
+                adap->props.pid_filter != NULL)
+                adap->props.pid_filter(adap, dvbdmxfeed->index, dvbdmxfeed->pid,onoff);
+
+        /* start the feed if this was the first feed and there is still a feed
+         * for reception.
+         */
+        if (adap->feedcount == onoff && adap->feedcount > 0) {
+                deb_ts("submitting all URBs\n");
+                usb_urb_submit(&adap->stream);
+
+                deb_ts("controlling pid parser\n");
+                if (adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER &&
+                        adap->props.caps &
+                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF &&
+                        adap->props.pid_filter_ctrl != NULL) {
+                        ret = adap->props.pid_filter_ctrl(adap,
+                                adap->pid_filtering);
+                        if (ret < 0) {
+                                err("could not handle pid_parser");
+                                return ret;
+                        }
+                }
+                deb_ts("start feeding\n");
+                if (adap->props.streaming_ctrl != NULL) {
+                        ret = adap->props.streaming_ctrl(adap, 1);
+                        if (ret < 0) {
+                                err("error while enabling fifo.");
+                                return ret;
+                        }
+                }
+
+        }
+        return 0;
+}
+
+static int dvb_usb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
+{
+        deb_ts("start pid: 0x%04x, feedtype: %d\n", dvbdmxfeed->pid,dvbdmxfeed->type);
+        return dvb_usb_ctrl_feed(dvbdmxfeed,1);
+}
+
+static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
+{
+        deb_ts("stop pid: 0x%04x, feedtype: %d\n", dvbdmxfeed->pid, dvbdmxfeed->type);
+        return dvb_usb_ctrl_feed(dvbdmxfeed,0);
+}
+
+int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap, short *adapter_nums)
+{
+        int ret = dvb_register_adapter(&adap->dvb_adap, adap->dev->desc->name,
+                                       adap->dev->owner, &adap->dev->udev->dev,
+                                       adapter_nums);
+
+        if (ret < 0) {
+                deb_info("dvb_register_adapter failed: error %d", ret);
+                goto err;
+        }
+        adap->dvb_adap.priv = adap;
+        adap->dvb_adap.fe_ioctl_override = adap->props.fe_ioctl_override;
+
+        if (adap->dev->props.read_mac_address) {
+                if (adap->dev->props.read_mac_address(adap->dev,adap->dvb_adap.proposed_mac) == 0)
+                        info("MAC address: %pM",adap->dvb_adap.proposed_mac);
+                else
+                        err("MAC address reading failed.");
+        }
+
+
+        adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
+        adap->demux.priv             = adap;
+
+        adap->demux.feednum          = adap->demux.filternum = adap->max_feed_count;
+        adap->demux.start_feed       = dvb_usb_start_feed;
+        adap->demux.stop_feed        = dvb_usb_stop_feed;
+        adap->demux.write_to_decoder = NULL;
+        if ((ret = dvb_dmx_init(&adap->demux)) < 0) {
+                err("dvb_dmx_init failed: error %d",ret);
+                goto err_dmx;
+        }
+
+        adap->dmxdev.filternum       = adap->demux.filternum;
+        adap->dmxdev.demux           = &adap->demux.dmx;
+        adap->dmxdev.capabilities    = 0;
+        if ((ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap)) < 0) {
+                err("dvb_dmxdev_init failed: error %d",ret);
+                goto err_dmx_dev;
+        }
+
+        dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx);
+
+        adap->state |= DVB_USB_ADAP_STATE_DVB;
+        return 0;
+
+err_dmx_dev:
+        dvb_dmx_release(&adap->demux);
+err_dmx:
+        dvb_unregister_adapter(&adap->dvb_adap);
+err:
+        return ret;
+}
+
+int dvb_usb_adapter_dvb_exit(struct dvb_usb_adapter *adap)
+{
+        if (adap->state & DVB_USB_ADAP_STATE_DVB) {
+                deb_info("unregistering DVB part\n");
+                dvb_net_release(&adap->dvb_net);
+                adap->demux.dmx.close(&adap->demux.dmx);
+                dvb_dmxdev_release(&adap->dmxdev);
+                dvb_dmx_release(&adap->demux);
+                dvb_unregister_adapter(&adap->dvb_adap);
+                adap->state &= ~DVB_USB_ADAP_STATE_DVB;
+        }
+        return 0;
+}
+
+static int dvb_usb_fe_wakeup(struct dvb_frontend *fe)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+
+        dvb_usb_device_power_ctrl(adap->dev, 1);
+
+        if (adap->fe_init)
+                adap->fe_init(fe);
+
+        return 0;
+}
+
+static int dvb_usb_fe_sleep(struct dvb_frontend *fe)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+
+        if (adap->fe_sleep)
+                adap->fe_sleep(fe);
+
+        return dvb_usb_device_power_ctrl(adap->dev, 0);
+}
+
+int dvb_usb_adapter_frontend_init(struct dvb_usb_adapter *adap)
+{
+        if (adap->props.frontend_attach == NULL) {
+                err("strange: '%s' #%d doesn't want to attach a frontend.",adap->dev->desc->name, adap->id);
+                return 0;
+        }
+
+        /* re-assign sleep and wakeup functions */
+        if (adap->props.frontend_attach(adap) == 0 && adap->fe != NULL) {
+                adap->fe_init  = adap->fe->ops.init;  adap->fe->ops.init  = dvb_usb_fe_wakeup;
+                adap->fe_sleep = adap->fe->ops.sleep; adap->fe->ops.sleep = dvb_usb_fe_sleep;
+
+                if (dvb_register_frontend(&adap->dvb_adap, adap->fe)) {
+                        err("Frontend registration failed.");
+                        dvb_frontend_detach(adap->fe);
+                        adap->fe = NULL;
+                        return -ENODEV;
+                }
+
+                /* only attach the tuner if the demod is there */
+                if (adap->props.tuner_attach != NULL)
+                        adap->props.tuner_attach(adap);
+        } else
+                err("no frontend was attached by '%s'",adap->dev->desc->name);
+
+        return 0;
+}
+
+int dvb_usb_adapter_frontend_exit(struct dvb_usb_adapter *adap)
+{
+        if (adap->fe != NULL) {
+                dvb_unregister_frontend(adap->fe);
+                dvb_frontend_detach(adap->fe);
+        }
+        return 0;
+}
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
new file mode 100644
index 00000000000..733a7ff7b20
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
@@ -0,0 +1,146 @@
+/* dvb-usb-firmware.c is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
+ * see dvb-usb-init.c for copyright information.
+ *
+ * This file contains functions for downloading the firmware to Cypress FX 1 and 2 based devices.
+ *
+ * FIXME: This part does actually not belong to dvb-usb, but to the usb-subsystem.
+ */
+#include "dvb-usb-common.h"
+
+#include <linux/usb.h>
+
+struct usb_cypress_controller {
+        int id;
+        const char *name;       /* name of the usb controller */
+        u16 cpu_cs_register;    /* needs to be restarted, when the firmware has been downloaded. */
+};
+
+static struct usb_cypress_controller cypress[] = {
+        { .id = DEVICE_SPECIFIC, .name = "Device specific", .cpu_cs_register = 0 },
+        { .id = CYPRESS_AN2135,  .name = "Cypress AN2135",  .cpu_cs_register = 0x7f92 },
+        { .id = CYPRESS_AN2235,  .name = "Cypress AN2235",  .cpu_cs_register = 0x7f92 },
+        { .id = CYPRESS_FX2,     .name = "Cypress FX2",     .cpu_cs_register = 0xe600 },
+};
+
+/*
+ * load a firmware packet to the device
+ */
+static int usb_cypress_writemem(struct usb_device *udev,u16 addr,u8 *data, u8 len)
+{
+        return usb_control_msg(udev, usb_sndctrlpipe(udev,0),
+                        0xa0, USB_TYPE_VENDOR, addr, 0x00, data, len, 5000);
+}
+
+int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type)
+{
+        struct hexline hx;
+        u8 reset;
+        int ret,pos=0;
+
+        /* stop the CPU */
+        reset = 1;
+        if ((ret = usb_cypress_writemem(udev,cypress[type].cpu_cs_register,&reset,1)) != 1)
+                err("could not stop the USB controller CPU.");
+
+        while ((ret = dvb_usb_get_hexline(fw,&hx,&pos)) > 0) {
+                deb_fw("writing to address 0x%04x (buffer: 0x%02x %02x)\n",hx.addr,hx.len,hx.chk);
+                ret = usb_cypress_writemem(udev,hx.addr,hx.data,hx.len);
+
+                if (ret != hx.len) {
+                        err("error while transferring firmware "
+                                "(transferred size: %d, block size: %d)",
+                                ret,hx.len);
+                        ret = -EINVAL;
+                        break;
+                }
+        }
+        if (ret < 0) {
+                err("firmware download failed at %d with %d",pos,ret);
+                return ret;
+        }
+
+        if (ret == 0) {
+                /* restart the CPU */
+                reset = 0;
+                if (ret || usb_cypress_writemem(udev,cypress[type].cpu_cs_register,&reset,1) != 1) {
+                        err("could not restart the USB controller CPU.");
+                        ret = -EINVAL;
+                }
+        } else
+                ret = -EIO;
+
+        return ret;
+}
+EXPORT_SYMBOL(usb_cypress_load_firmware);
+
+int dvb_usb_download_firmware(struct usb_device *udev, struct dvb_usb_device_properties *props)
+{
+        int ret;
+        const struct firmware *fw = NULL;
+
+        if ((ret = request_firmware(&fw, props->firmware, &udev->dev)) != 0) {
+                err("did not find the firmware file. (%s) "
+                        "Please see linux/Documentation/dvb/ for more details on firmware-problems. (%d)",
+                        props->firmware,ret);
+                return ret;
+        }
+
+        info("downloading firmware from file '%s'",props->firmware);
+
+        switch (props->usb_ctrl) {
+                case CYPRESS_AN2135:
+                case CYPRESS_AN2235:
+                case CYPRESS_FX2:
+                        ret = usb_cypress_load_firmware(udev, fw, props->usb_ctrl);
+                        break;
+                case DEVICE_SPECIFIC:
+                        if (props->download_firmware)
+                                ret = props->download_firmware(udev,fw);
+                        else {
+                                err("BUG: driver didn't specified a download_firmware-callback, although it claims to have a DEVICE_SPECIFIC one.");
+                                ret = -EINVAL;
+                        }
+                        break;
+                default:
+                        ret = -EINVAL;
+                        break;
+        }
+
+        release_firmware(fw);
+        return ret;
+}
+
+int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx,
+                               int *pos)
+{
+        u8 *b = (u8 *) &fw->data[*pos];
+        int data_offs = 4;
+        if (*pos >= fw->size)
+                return 0;
+
+        memset(hx,0,sizeof(struct hexline));
+
+        hx->len  = b[0];
+
+        if ((*pos + hx->len + 4) >= fw->size)
+                return -EINVAL;
+
+        hx->addr = b[1] | (b[2] << 8);
+        hx->type = b[3];
+
+        if (hx->type == 0x04) {
+                /* b[4] and b[5] are the Extended linear address record data field */
+                hx->addr |= (b[4] << 24) | (b[5] << 16);
+/*              hx->len -= 2;
+                data_offs += 2; */
+        }
+        memcpy(hx->data,&b[data_offs],hx->len);
+        hx->chk = b[hx->len + data_offs];
+
+        *pos += hx->len + 5;
+
+        return *pos;
+}
+EXPORT_SYMBOL(dvb_usb_get_hexline);
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-i2c.c b/drivers/media/dvb/dvb-usb/dvb-usb-i2c.c
new file mode 100644
index 00000000000..88e4a62abc4
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-i2c.c
@@ -0,0 +1,43 @@
+/* dvb-usb-i2c.c is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
+ * see dvb-usb-init.c for copyright information.
+ *
+ * This file contains functions for (de-)initializing an I2C adapter.
+ */
+#include "dvb-usb-common.h"
+
+int dvb_usb_i2c_init(struct dvb_usb_device *d)
+{
+        int ret = 0;
+
+        if (!(d->props.caps & DVB_USB_IS_AN_I2C_ADAPTER))
+                return 0;
+
+        if (d->props.i2c_algo == NULL) {
+                err("no i2c algorithm specified");
+                return -EINVAL;
+        }
+
+        strlcpy(d->i2c_adap.name, d->desc->name, sizeof(d->i2c_adap.name));
+        d->i2c_adap.algo      = d->props.i2c_algo;
+        d->i2c_adap.algo_data = NULL;
+        d->i2c_adap.dev.parent = &d->udev->dev;
+
+        i2c_set_adapdata(&d->i2c_adap, d);
+
+        if ((ret = i2c_add_adapter(&d->i2c_adap)) < 0)
+                err("could not add i2c adapter");
+
+        d->state |= DVB_USB_STATE_I2C;
+
+        return ret;
+}
+
+int dvb_usb_i2c_exit(struct dvb_usb_device *d)
+{
+        if (d->state & DVB_USB_STATE_I2C)
+                i2c_del_adapter(&d->i2c_adap);
+        d->state &= ~DVB_USB_STATE_I2C;
+        return 0;
+}
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-ids.h b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
new file mode 100644
index 00000000000..2a79b8fb3e8
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
@@ -0,0 +1,326 @@
+/* dvb-usb-ids.h is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de) see
+ * dvb-usb-init.c for copyright information.
+ *
+ * a header file containing define's for the USB device supported by the
+ * various drivers.
+ */
+#ifndef _DVB_USB_IDS_H_
+#define _DVB_USB_IDS_H_
+
+/* Vendor IDs */
+#define USB_VID_ADSTECH                         0x06e1
+#define USB_VID_AFATECH                         0x15a4
+#define USB_VID_ALCOR_MICRO                     0x058f
+#define USB_VID_ALINK                           0x05e3
+#define USB_VID_AMT                             0x1c73
+#define USB_VID_ANCHOR                          0x0547
+#define USB_VID_ANSONIC                         0x10b9
+#define USB_VID_ANUBIS_ELECTRONIC               0x10fd
+#define USB_VID_ASUS                            0x0b05
+#define USB_VID_AVERMEDIA                       0x07ca
+#define USB_VID_COMPRO                          0x185b
+#define USB_VID_COMPRO_UNK                      0x145f
+#define USB_VID_CONEXANT                        0x0572
+#define USB_VID_CYPRESS                         0x04b4
+#define USB_VID_DIBCOM                          0x10b8
+#define USB_VID_DPOSH                           0x1498
+#define USB_VID_DVICO                           0x0fe9
+#define USB_VID_E3C                             0x18b4
+#define USB_VID_ELGATO                          0x0fd9
+#define USB_VID_EMPIA                           0xeb1a
+#define USB_VID_GENPIX                          0x09c0
+#define USB_VID_GRANDTEC                        0x5032
+#define USB_VID_GTEK                            0x1f4d
+#define USB_VID_HANFTEK                         0x15f4
+#define USB_VID_HAUPPAUGE                       0x2040
+#define USB_VID_HYPER_PALTEK                    0x1025
+#define USB_VID_INTEL                           0x8086
+#define USB_VID_KWORLD                          0xeb2a
+#define USB_VID_KWORLD_2                        0x1b80
+#define USB_VID_KYE                             0x0458
+#define USB_VID_LEADTEK                         0x0413
+#define USB_VID_LITEON                          0x04ca
+#define USB_VID_MEDION                          0x1660
+#define USB_VID_MIGLIA                          0x18f3
+#define USB_VID_MSI                             0x0db0
+#define USB_VID_MSI_2                           0x1462
+#define USB_VID_OPERA1                          0x695c
+#define USB_VID_PINNACLE                        0x2304
+#define USB_VID_PCTV                            0x2013
+#define USB_VID_PIXELVIEW                       0x1554
+#define USB_VID_TECHNOTREND                     0x0b48
+#define USB_VID_TERRATEC                        0x0ccd
+#define USB_VID_TELESTAR                        0x10b9
+#define USB_VID_VISIONPLUS                      0x13d3
+#define USB_VID_SONY                            0x1415
+#define USB_VID_TWINHAN                         0x1822
+#define USB_VID_ULTIMA_ELECTRONIC               0x05d8
+#define USB_VID_UNIWILL                         0x1584
+#define USB_VID_WIDEVIEW                        0x14aa
+#define USB_VID_GIGABYTE                        0x1044
+#define USB_VID_YUAN                            0x1164
+#define USB_VID_XTENSIONS                       0x1ae7
+#define USB_VID_HUMAX_COEX                      0x10b9
+#define USB_VID_774                             0x7a69
+#define USB_VID_EVOLUTEPC                       0x1e59
+#define USB_VID_AZUREWAVE                       0x13d3
+#define USB_VID_TECHNISAT                       0x14f7
+
+/* Product IDs */
+#define USB_PID_ADSTECH_USB2_COLD                       0xa333
+#define USB_PID_ADSTECH_USB2_WARM                       0xa334
+#define USB_PID_AFATECH_AF9005                          0x9020
+#define USB_PID_AFATECH_AF9015_9015                     0x9015
+#define USB_PID_AFATECH_AF9015_9016                     0x9016
+#define USB_PID_TREKSTOR_DVBT                           0x901b
+#define USB_VID_ALINK_DTU                               0xf170
+#define USB_PID_ANSONIC_DVBT_USB                        0x6000
+#define USB_PID_ANYSEE                                  0x861f
+#define USB_PID_AZUREWAVE_AD_TU700                      0x3237
+#define USB_PID_AVERMEDIA_DVBT_USB_COLD                 0x0001
+#define USB_PID_AVERMEDIA_DVBT_USB_WARM                 0x0002
+#define USB_PID_AVERMEDIA_DVBT_USB2_COLD                0xa800
+#define USB_PID_AVERMEDIA_DVBT_USB2_WARM                0xa801
+#define USB_PID_COMPRO_DVBU2000_COLD                    0xd000
+#define USB_PID_COMPRO_DVBU2000_WARM                    0xd001
+#define USB_PID_COMPRO_DVBU2000_UNK_COLD                0x010c
+#define USB_PID_COMPRO_DVBU2000_UNK_WARM                0x010d
+#define USB_PID_COMPRO_VIDEOMATE_U500                   0x1e78
+#define USB_PID_COMPRO_VIDEOMATE_U500_PC                0x1e80
+#define USB_PID_CONCEPTRONIC_CTVDIGRCU                  0xe397
+#define USB_PID_CONEXANT_D680_DMB                       0x86d6
+#define USB_PID_CREATIX_CTX1921                         0x1921
+#define USB_PID_DIBCOM_HOOK_DEFAULT                     0x0064
+#define USB_PID_DIBCOM_HOOK_DEFAULT_REENUM              0x0065
+#define USB_PID_DIBCOM_MOD3000_COLD                     0x0bb8
+#define USB_PID_DIBCOM_MOD3000_WARM                     0x0bb9
+#define USB_PID_DIBCOM_MOD3001_COLD                     0x0bc6
+#define USB_PID_DIBCOM_MOD3001_WARM                     0x0bc7
+#define USB_PID_DIBCOM_STK7700P                         0x1e14
+#define USB_PID_DIBCOM_STK7700P_PC                      0x1e78
+#define USB_PID_DIBCOM_STK7700D                         0x1ef0
+#define USB_PID_DIBCOM_STK7700_U7000                    0x7001
+#define USB_PID_DIBCOM_STK7070P                         0x1ebc
+#define USB_PID_DIBCOM_STK7070PD                        0x1ebe
+#define USB_PID_DIBCOM_STK807XP                         0x1f90
+#define USB_PID_DIBCOM_STK807XPVR                       0x1f98
+#define USB_PID_DIBCOM_STK8096GP                        0x1fa0
+#define USB_PID_DIBCOM_NIM8096MD                        0x1fa8
+#define USB_PID_DIBCOM_ANCHOR_2135_COLD                 0x2131
+#define USB_PID_DIBCOM_STK7770P                         0x1e80
+#define USB_PID_DIBCOM_NIM7090                          0x1bb2
+#define USB_PID_DIBCOM_TFE7090PVR                       0x1bb4
+#define USB_PID_DIBCOM_NIM9090M                         0x2383
+#define USB_PID_DIBCOM_NIM9090MD                        0x2384
+#define USB_PID_DPOSH_M9206_COLD                        0x9206
+#define USB_PID_DPOSH_M9206_WARM                        0xa090
+#define USB_PID_E3C_EC168                               0x1689
+#define USB_PID_E3C_EC168_2                             0xfffa
+#define USB_PID_E3C_EC168_3                             0xfffb
+#define USB_PID_E3C_EC168_4                             0x1001
+#define USB_PID_E3C_EC168_5                             0x1002
+#define USB_PID_UNIWILL_STK7700P                        0x6003
+#define USB_PID_GENIUS_TVGO_DVB_T03                     0x4012
+#define USB_PID_GRANDTEC_DVBT_USB_COLD                  0x0fa0
+#define USB_PID_GRANDTEC_DVBT_USB_WARM                  0x0fa1
+#define USB_PID_INTEL_CE9500                            0x9500
+#define USB_PID_KWORLD_399U                             0xe399
+#define USB_PID_KWORLD_399U_2                           0xe400
+#define USB_PID_KWORLD_395U                             0xe396
+#define USB_PID_KWORLD_395U_2                           0xe39b
+#define USB_PID_KWORLD_395U_3                           0xe395
+#define USB_PID_KWORLD_395U_4                           0xe39a
+#define USB_PID_KWORLD_MC810                            0xc810
+#define USB_PID_KWORLD_PC160_2T                         0xc160
+#define USB_PID_KWORLD_PC160_T                          0xc161
+#define USB_PID_KWORLD_UB383_T                          0xe383
+#define USB_PID_KWORLD_VSTREAM_COLD                     0x17de
+#define USB_PID_KWORLD_VSTREAM_WARM                     0x17df
+#define USB_PID_TERRATEC_CINERGY_T_USB_XE               0x0055
+#define USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2          0x0069
+#define USB_PID_TERRATEC_CINERGY_T_STICK_RC             0x0097
+#define USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC        0x0099
+#define USB_PID_TWINHAN_VP7041_COLD                     0x3201
+#define USB_PID_TWINHAN_VP7041_WARM                     0x3202
+#define USB_PID_TWINHAN_VP7020_COLD                     0x3203
+#define USB_PID_TWINHAN_VP7020_WARM                     0x3204
+#define USB_PID_TWINHAN_VP7045_COLD                     0x3205
+#define USB_PID_TWINHAN_VP7045_WARM                     0x3206
+#define USB_PID_TWINHAN_VP7021_COLD                     0x3207
+#define USB_PID_TWINHAN_VP7021_WARM                     0x3208
+#define USB_PID_TINYTWIN                                0x3226
+#define USB_PID_TINYTWIN_2                              0xe402
+#define USB_PID_TINYTWIN_3                              0x9016
+#define USB_PID_DNTV_TINYUSB2_COLD                      0x3223
+#define USB_PID_DNTV_TINYUSB2_WARM                      0x3224
+#define USB_PID_ULTIMA_TVBOX_COLD                       0x8105
+#define USB_PID_ULTIMA_TVBOX_WARM                       0x8106
+#define USB_PID_ULTIMA_TVBOX_AN2235_COLD                0x8107
+#define USB_PID_ULTIMA_TVBOX_AN2235_WARM                0x8108
+#define USB_PID_ULTIMA_TVBOX_ANCHOR_COLD                0x2235
+#define USB_PID_ULTIMA_TVBOX_USB2_COLD                  0x8109
+#define USB_PID_ULTIMA_TVBOX_USB2_WARM                  0x810a
+#define USB_PID_ARTEC_T14_COLD                          0x810b
+#define USB_PID_ARTEC_T14_WARM                          0x810c
+#define USB_PID_ARTEC_T14BR                             0x810f
+#define USB_PID_ULTIMA_TVBOX_USB2_FX_COLD               0x8613
+#define USB_PID_ULTIMA_TVBOX_USB2_FX_WARM               0x1002
+#define USB_PID_UNK_HYPER_PALTEK_COLD                   0x005e
+#define USB_PID_UNK_HYPER_PALTEK_WARM                   0x005f
+#define USB_PID_HANFTEK_UMT_010_COLD                    0x0001
+#define USB_PID_HANFTEK_UMT_010_WARM                    0x0015
+#define USB_PID_DTT200U_COLD                            0x0201
+#define USB_PID_DTT200U_WARM                            0x0301
+#define USB_PID_WT220U_ZAP250_COLD                      0x0220
+#define USB_PID_WT220U_COLD                             0x0222
+#define USB_PID_WT220U_WARM                             0x0221
+#define USB_PID_WT220U_FC_COLD                          0x0225
+#define USB_PID_WT220U_FC_WARM                          0x0226
+#define USB_PID_WT220U_ZL0353_COLD                      0x022a
+#define USB_PID_WT220U_ZL0353_WARM                      0x022b
+#define USB_PID_WINTV_NOVA_T_USB2_COLD                  0x9300
+#define USB_PID_WINTV_NOVA_T_USB2_WARM                  0x9301
+#define USB_PID_HAUPPAUGE_NOVA_T_500                    0x9941
+#define USB_PID_HAUPPAUGE_NOVA_T_500_2                  0x9950
+#define USB_PID_HAUPPAUGE_NOVA_T_500_3                  0x8400
+#define USB_PID_HAUPPAUGE_NOVA_T_STICK                  0x7050
+#define USB_PID_HAUPPAUGE_NOVA_T_STICK_2                0x7060
+#define USB_PID_HAUPPAUGE_NOVA_T_STICK_3                0x7070
+#define USB_PID_HAUPPAUGE_MYTV_T                        0x7080
+#define USB_PID_HAUPPAUGE_NOVA_TD_STICK                 0x9580
+#define USB_PID_HAUPPAUGE_NOVA_TD_STICK_52009           0x5200
+#define USB_PID_HAUPPAUGE_TIGER_ATSC                    0xb200
+#define USB_PID_HAUPPAUGE_TIGER_ATSC_B210               0xb210
+#define USB_PID_AVERMEDIA_EXPRESS                       0xb568
+#define USB_PID_AVERMEDIA_VOLAR                         0xa807
+#define USB_PID_AVERMEDIA_VOLAR_2                       0xb808
+#define USB_PID_AVERMEDIA_VOLAR_A868R                   0xa868
+#define USB_PID_AVERMEDIA_MCE_USB_M038                  0x1228
+#define USB_PID_AVERMEDIA_HYBRID_ULTRA_USB_M039R        0x0039
+#define USB_PID_AVERMEDIA_HYBRID_ULTRA_USB_M039R_ATSC   0x1039
+#define USB_PID_AVERMEDIA_HYBRID_ULTRA_USB_M039R_DVBT   0x2039
+#define USB_PID_AVERMEDIA_VOLAR_X                       0xa815
+#define USB_PID_AVERMEDIA_VOLAR_X_2                     0x8150
+#define USB_PID_AVERMEDIA_A309                          0xa309
+#define USB_PID_AVERMEDIA_A310                          0xa310
+#define USB_PID_AVERMEDIA_A850                          0x850a
+#define USB_PID_AVERMEDIA_A850T                         0x850b
+#define USB_PID_AVERMEDIA_A805                          0xa805
+#define USB_PID_AVERMEDIA_A815M                         0x815a
+#define USB_PID_TECHNOTREND_CONNECT_S2400               0x3006
+#define USB_PID_TECHNOTREND_CONNECT_CT3650              0x300d
+#define USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY        0x005a
+#define USB_PID_TERRATEC_CINERGY_DT_XS_DIVERSITY_2      0x0081
+#define USB_PID_TERRATEC_CINERGY_HT_USB_XE              0x0058
+#define USB_PID_TERRATEC_CINERGY_HT_EXPRESS             0x0060
+#define USB_PID_TERRATEC_CINERGY_T_EXPRESS              0x0062
+#define USB_PID_TERRATEC_CINERGY_T_XXS                  0x0078
+#define USB_PID_TERRATEC_CINERGY_T_XXS_2                0x00ab
+#define USB_PID_TERRATEC_T3                             0x10a0
+#define USB_PID_TERRATEC_T5                             0x10a1
+#define USB_PID_PINNACLE_EXPRESSCARD_320CX              0x022e
+#define USB_PID_PINNACLE_PCTV2000E                      0x022c
+#define USB_PID_PINNACLE_PCTV_DVB_T_FLASH               0x0228
+#define USB_PID_PINNACLE_PCTV_DUAL_DIVERSITY_DVB_T      0x0229
+#define USB_PID_PINNACLE_PCTV71E                        0x022b
+#define USB_PID_PINNACLE_PCTV72E                        0x0236
+#define USB_PID_PINNACLE_PCTV73E                        0x0237
+#define USB_PID_PINNACLE_PCTV310E                       0x3211
+#define USB_PID_PINNACLE_PCTV801E                       0x023a
+#define USB_PID_PINNACLE_PCTV801E_SE                    0x023b
+#define USB_PID_PINNACLE_PCTV340E                       0x023d
+#define USB_PID_PINNACLE_PCTV340E_SE                    0x023e
+#define USB_PID_PINNACLE_PCTV73A                        0x0243
+#define USB_PID_PINNACLE_PCTV73ESE                      0x0245
+#define USB_PID_PINNACLE_PCTV74E                        0x0246
+#define USB_PID_PINNACLE_PCTV282E                       0x0248
+#define USB_PID_PIXELVIEW_SBTVD                         0x5010
+#define USB_PID_PCTV_200E                               0x020e
+#define USB_PID_PCTV_400E                               0x020f
+#define USB_PID_PCTV_450E                               0x0222
+#define USB_PID_NEBULA_DIGITV                           0x0201
+#define USB_PID_DVICO_BLUEBIRD_LGDT                     0xd820
+#define USB_PID_DVICO_BLUEBIRD_LG064F_COLD              0xd500
+#define USB_PID_DVICO_BLUEBIRD_LG064F_WARM              0xd501
+#define USB_PID_DVICO_BLUEBIRD_LGZ201_COLD              0xdb00
+#define USB_PID_DVICO_BLUEBIRD_LGZ201_WARM              0xdb01
+#define USB_PID_DVICO_BLUEBIRD_TH7579_COLD              0xdb10
+#define USB_PID_DVICO_BLUEBIRD_TH7579_WARM              0xdb11
+#define USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD              0xdb50
+#define USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM              0xdb51
+#define USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD              0xdb58
+#define USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM              0xdb59
+#define USB_PID_DVICO_BLUEBIRD_DUAL_4                   0xdb78
+#define USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2             0xdb98
+#define USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2             0xdb70
+#define USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM    0xdb71
+#define USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD         0xdb54
+#define USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM         0xdb55
+#define USB_PID_MEDION_MD95700                          0x0932
+#define USB_PID_MSI_MEGASKY580                          0x5580
+#define USB_PID_MSI_MEGASKY580_55801                    0x5581
+#define USB_PID_KYE_DVB_T_COLD                          0x701e
+#define USB_PID_KYE_DVB_T_WARM                          0x701f
+#define USB_PID_LITEON_DVB_T_COLD                       0xf000
+#define USB_PID_LITEON_DVB_T_WARM                       0xf001
+#define USB_PID_DIGIVOX_MINI_SL_COLD                    0xe360
+#define USB_PID_DIGIVOX_MINI_SL_WARM                    0xe361
+#define USB_PID_GRANDTEC_DVBT_USB2_COLD                 0x0bc6
+#define USB_PID_GRANDTEC_DVBT_USB2_WARM                 0x0bc7
+#define USB_PID_WINFAST_DTV2000DS                       0x6a04
+#define USB_PID_WINFAST_DTV_DONGLE_COLD                 0x6025
+#define USB_PID_WINFAST_DTV_DONGLE_WARM                 0x6026
+#define USB_PID_WINFAST_DTV_DONGLE_STK7700P             0x6f00
+#define USB_PID_WINFAST_DTV_DONGLE_H                    0x60f6
+#define USB_PID_WINFAST_DTV_DONGLE_STK7700P_2           0x6f01
+#define USB_PID_WINFAST_DTV_DONGLE_GOLD                 0x6029
+#define USB_PID_GENPIX_8PSK_REV_1_COLD                  0x0200
+#define USB_PID_GENPIX_8PSK_REV_1_WARM                  0x0201
+#define USB_PID_GENPIX_8PSK_REV_2                       0x0202
+#define USB_PID_GENPIX_SKYWALKER_1                      0x0203
+#define USB_PID_GENPIX_SKYWALKER_CW3K                   0x0204
+#define USB_PID_GENPIX_SKYWALKER_2                      0x0206
+#define USB_PID_SIGMATEK_DVB_110                        0x6610
+#define USB_PID_MSI_DIGI_VOX_MINI_II                    0x1513
+#define USB_PID_MSI_DIGIVOX_DUO                         0x8801
+#define USB_PID_OPERA1_COLD                             0x2830
+#define USB_PID_OPERA1_WARM                             0x3829
+#define USB_PID_LIFEVIEW_TV_WALKER_TWIN_COLD            0x0514
+#define USB_PID_LIFEVIEW_TV_WALKER_TWIN_WARM            0x0513
+#define USB_PID_GIGABYTE_U7000                          0x7001
+#define USB_PID_GIGABYTE_U8000                          0x7002
+#define USB_PID_ASUS_U3000                              0x171f
+#define USB_PID_ASUS_U3000H                             0x1736
+#define USB_PID_ASUS_U3100                              0x173f
+#define USB_PID_YUAN_EC372S                             0x1edc
+#define USB_PID_YUAN_STK7700PH                          0x1f08
+#define USB_PID_YUAN_PD378S                             0x2edc
+#define USB_PID_YUAN_MC770                              0x0871
+#define USB_PID_YUAN_STK7700D                           0x1efc
+#define USB_PID_YUAN_STK7700D_2                         0x1e8c
+#define USB_PID_DW2102                                  0x2102
+#define USB_PID_XTENSIONS_XD_380                        0x0381
+#define USB_PID_TELESTAR_STARSTICK_2                    0x8000
+#define USB_PID_MSI_DIGI_VOX_MINI_III                   0x8807
+#define USB_PID_SONY_PLAYTV                             0x0003
+#define USB_PID_MYGICA_D689                             0xd811
+#define USB_PID_ELGATO_EYETV_DIVERSITY                  0x0011
+#define USB_PID_ELGATO_EYETV_DTT                        0x0021
+#define USB_PID_ELGATO_EYETV_DTT_Dlx                    0x0020
+#define USB_PID_ELGATO_EYETV_SAT                        0x002a
+#define USB_PID_DVB_T_USB_STICK_HIGH_SPEED_COLD         0x5000
+#define USB_PID_DVB_T_USB_STICK_HIGH_SPEED_WARM         0x5001
+#define USB_PID_FRIIO_WHITE                             0x0001
+#define USB_PID_TVWAY_PLUS                              0x0002
+#define USB_PID_SVEON_STV20                             0xe39d
+#define USB_PID_SVEON_STV22                             0xe401
+#define USB_PID_AZUREWAVE_AZ6027                        0x3275
+#define USB_PID_TERRATEC_DVBS2CI_V1                     0x10a4
+#define USB_PID_TERRATEC_DVBS2CI_V2                     0x10ac
+#define USB_PID_TECHNISAT_USB2_HDCI_V1                  0x0001
+#define USB_PID_TECHNISAT_USB2_HDCI_V2                  0x0002
+#define USB_PID_TECHNISAT_AIRSTAR_TELESTICK_2           0x0004
+#define USB_PID_TECHNISAT_USB2_DVB_S2                   0x0500
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-init.c b/drivers/media/dvb/dvb-usb/dvb-usb-init.c
new file mode 100644
index 00000000000..2e3ea0fa28e
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-init.c
@@ -0,0 +1,289 @@
+/*
+ * DVB USB library - provides a generic interface for a DVB USB device driver.
+ *
+ * dvb-usb-init.c
+ *
+ * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dvb-usb-common.h"
+
+/* debug */
+int dvb_usb_debug;
+module_param_named(debug, dvb_usb_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64,mem=128,uxfer=256  (or-able))." DVB_USB_DEBUG_STATUS);
+
+int dvb_usb_disable_rc_polling;
+module_param_named(disable_rc_polling, dvb_usb_disable_rc_polling, int, 0644);
+MODULE_PARM_DESC(disable_rc_polling, "disable remote control polling (default: 0).");
+
+static int dvb_usb_force_pid_filter_usage;
+module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage, int, 0444);
+MODULE_PARM_DESC(force_pid_filter_usage, "force all dvb-usb-devices to use a PID filter, if any (default: 0).");
+
+static int dvb_usb_adapter_init(struct dvb_usb_device *d, short *adapter_nrs)
+{
+        struct dvb_usb_adapter *adap;
+        int ret, n;
+
+        for (n = 0; n < d->props.num_adapters; n++) {
+                adap = &d->adapter[n];
+                adap->dev = d;
+                adap->id  = n;
+
+                memcpy(&adap->props, &d->props.adapter[n], sizeof(struct dvb_usb_adapter_properties));
+
+                /* speed - when running at FULL speed we need a HW PID filter */
+                if (d->udev->speed == USB_SPEED_FULL && !(adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
+                        err("This USB2.0 device cannot be run on a USB1.1 port. (it lacks a hardware PID filter)");
+                        return -ENODEV;
+                }
+
+                if ((d->udev->speed == USB_SPEED_FULL && adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
+                        (adap->props.caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
+                        info("will use the device's hardware PID filter (table count: %d).", adap->props.pid_filter_count);
+                        adap->pid_filtering  = 1;
+                        adap->max_feed_count = adap->props.pid_filter_count;
+                } else {
+                        info("will pass the complete MPEG2 transport stream to the software demuxer.");
+                        adap->pid_filtering  = 0;
+                        adap->max_feed_count = 255;
+                }
+
+                if (!adap->pid_filtering &&
+                        dvb_usb_force_pid_filter_usage &&
+                        adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER) {
+                        info("pid filter enabled by module option.");
+                        adap->pid_filtering  = 1;
+                        adap->max_feed_count = adap->props.pid_filter_count;
+                }
+
+                if (adap->props.size_of_priv > 0) {
+                        adap->priv = kzalloc(adap->props.size_of_priv, GFP_KERNEL);
+                        if (adap->priv == NULL) {
+                                err("no memory for priv for adapter %d.", n);
+                                return -ENOMEM;
+                        }
+                }
+
+                if ((ret = dvb_usb_adapter_stream_init(adap)) ||
+                        (ret = dvb_usb_adapter_dvb_init(adap, adapter_nrs)) ||
+                        (ret = dvb_usb_adapter_frontend_init(adap))) {
+                        return ret;
+                }
+
+                d->num_adapters_initialized++;
+                d->state |= DVB_USB_STATE_DVB;
+        }
+
+        /*
+         * when reloading the driver w/o replugging the device
+         * sometimes a timeout occures, this helps
+         */
+        if (d->props.generic_bulk_ctrl_endpoint != 0) {
+                usb_clear_halt(d->udev, usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
+                usb_clear_halt(d->udev, usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
+        }
+
+        return 0;
+}
+
+static int dvb_usb_adapter_exit(struct dvb_usb_device *d)
+{
+        int n;
+
+        for (n = 0; n < d->num_adapters_initialized; n++) {
+                dvb_usb_adapter_frontend_exit(&d->adapter[n]);
+                dvb_usb_adapter_dvb_exit(&d->adapter[n]);
+                dvb_usb_adapter_stream_exit(&d->adapter[n]);
+                kfree(d->adapter[n].priv);
+        }
+        d->num_adapters_initialized = 0;
+        d->state &= ~DVB_USB_STATE_DVB;
+        return 0;
+}
+
+
+/* general initialization functions */
+static int dvb_usb_exit(struct dvb_usb_device *d)
+{
+        deb_info("state before exiting everything: %x\n", d->state);
+        dvb_usb_remote_exit(d);
+        dvb_usb_adapter_exit(d);
+        dvb_usb_i2c_exit(d);
+        deb_info("state should be zero now: %x\n", d->state);
+        d->state = DVB_USB_STATE_INIT;
+        kfree(d->priv);
+        kfree(d);
+        return 0;
+}
+
+static int dvb_usb_init(struct dvb_usb_device *d, short *adapter_nums)
+{
+        int ret = 0;
+
+        mutex_init(&d->usb_mutex);
+        mutex_init(&d->i2c_mutex);
+
+        d->state = DVB_USB_STATE_INIT;
+
+        if (d->props.size_of_priv > 0) {
+                d->priv = kzalloc(d->props.size_of_priv, GFP_KERNEL);
+                if (d->priv == NULL) {
+                        err("no memory for priv in 'struct dvb_usb_device'");
+                        return -ENOMEM;
+                }
+        }
+
+        /* check the capabilities and set appropriate variables */
+        dvb_usb_device_power_ctrl(d, 1);
+
+        if ((ret = dvb_usb_i2c_init(d)) ||
+                (ret = dvb_usb_adapter_init(d, adapter_nums))) {
+                dvb_usb_exit(d);
+                return ret;
+        }
+
+        if ((ret = dvb_usb_remote_init(d)))
+                err("could not initialize remote control.");
+
+        dvb_usb_device_power_ctrl(d, 0);
+
+        return 0;
+}
+
+/* determine the name and the state of the just found USB device */
+static struct dvb_usb_device_description *dvb_usb_find_device(struct usb_device *udev, struct dvb_usb_device_properties *props, int *cold)
+{
+        int i, j;
+        struct dvb_usb_device_description *desc = NULL;
+
+        *cold = -1;
+
+        for (i = 0; i < props->num_device_descs; i++) {
+
+                for (j = 0; j < DVB_USB_ID_MAX_NUM && props->devices[i].cold_ids[j] != NULL; j++) {
+                        deb_info("check for cold %x %x\n", props->devices[i].cold_ids[j]->idVendor, props->devices[i].cold_ids[j]->idProduct);
+                        if (props->devices[i].cold_ids[j]->idVendor  == le16_to_cpu(udev->descriptor.idVendor) &&
+                                props->devices[i].cold_ids[j]->idProduct == le16_to_cpu(udev->descriptor.idProduct)) {
+                                *cold = 1;
+                                desc = &props->devices[i];
+                                break;
+                        }
+                }
+
+                if (desc != NULL)
+                        break;
+
+                for (j = 0; j < DVB_USB_ID_MAX_NUM && props->devices[i].warm_ids[j] != NULL; j++) {
+                        deb_info("check for warm %x %x\n", props->devices[i].warm_ids[j]->idVendor, props->devices[i].warm_ids[j]->idProduct);
+                        if (props->devices[i].warm_ids[j]->idVendor == le16_to_cpu(udev->descriptor.idVendor) &&
+                                props->devices[i].warm_ids[j]->idProduct == le16_to_cpu(udev->descriptor.idProduct)) {
+                                *cold = 0;
+                                desc = &props->devices[i];
+                                break;
+                        }
+                }
+        }
+
+        if (desc != NULL && props->identify_state != NULL)
+                props->identify_state(udev, props, &desc, cold);
+
+        return desc;
+}
+
+int dvb_usb_device_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        if (onoff)
+                d->powered++;
+        else
+                d->powered--;
+
+        if (d->powered == 0 || (onoff && d->powered == 1)) { /* when switching from 1 to 0 or from 0 to 1 */
+                deb_info("power control: %d\n", onoff);
+                if (d->props.power_ctrl)
+                        return d->props.power_ctrl(d, onoff);
+        }
+        return 0;
+}
+
+/*
+ * USB
+ */
+int dvb_usb_device_init(struct usb_interface *intf,
+                        struct dvb_usb_device_properties *props,
+                        struct module *owner, struct dvb_usb_device **du,
+                        short *adapter_nums)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct dvb_usb_device *d = NULL;
+        struct dvb_usb_device_description *desc = NULL;
+
+        int ret = -ENOMEM, cold = 0;
+
+        if (du != NULL)
+                *du = NULL;
+
+        if ((desc = dvb_usb_find_device(udev, props, &cold)) == NULL) {
+                deb_err("something went very wrong, device was not found in current device list - let's see what comes next.\n");
+                return -ENODEV;
+        }
+
+        if (cold) {
+                info("found a '%s' in cold state, will try to load a firmware", desc->name);
+                ret = dvb_usb_download_firmware(udev, props);
+                if (!props->no_reconnect || ret != 0)
+                        return ret;
+        }
+
+        info("found a '%s' in warm state.", desc->name);
+        d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL);
+        if (d == NULL) {
+                err("no memory for 'struct dvb_usb_device'");
+                return -ENOMEM;
+        }
+
+        d->udev = udev;
+        memcpy(&d->props, props, sizeof(struct dvb_usb_device_properties));
+        d->desc = desc;
+        d->owner = owner;
+
+        usb_set_intfdata(intf, d);
+
+        if (du != NULL)
+                *du = d;
+
+        ret = dvb_usb_init(d, adapter_nums);
+
+        if (ret == 0)
+                info("%s successfully initialized and connected.", desc->name);
+        else
+                info("%s error while loading driver (%d)", desc->name, ret);
+        return ret;
+}
+EXPORT_SYMBOL(dvb_usb_device_init);
+
+void dvb_usb_device_exit(struct usb_interface *intf)
+{
+        struct dvb_usb_device *d = usb_get_intfdata(intf);
+        const char *name = "generic DVB-USB module";
+
+        usb_set_intfdata(intf, NULL);
+        if (d != NULL && d->desc != NULL) {
+                name = d->desc->name;
+                dvb_usb_exit(d);
+        }
+        info("%s successfully deinitialized and disconnected.", name);
+
+}
+EXPORT_SYMBOL(dvb_usb_device_exit);
+
+MODULE_VERSION("1.0");
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("A library module containing commonly used USB and DVB function USB DVB devices");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-remote.c b/drivers/media/dvb/dvb-usb/dvb-usb-remote.c
new file mode 100644
index 00000000000..41bacff2496
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-remote.c
@@ -0,0 +1,391 @@
+/* dvb-usb-remote.c is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
+ * see dvb-usb-init.c for copyright information.
+ *
+ * This file contains functions for initializing the input-device and for handling remote-control-queries.
+ */
+#include "dvb-usb-common.h"
+#include <linux/usb/input.h>
+
+static unsigned int
+legacy_dvb_usb_get_keymap_index(const struct input_keymap_entry *ke,
+                                struct rc_map_table *keymap,
+                                unsigned int keymap_size)
+{
+        unsigned int index;
+        unsigned int scancode;
+
+        if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
+                index = ke->index;
+        } else {
+                if (input_scancode_to_scalar(ke, &scancode))
+                        return keymap_size;
+
+                /* See if we can match the raw key code. */
+                for (index = 0; index < keymap_size; index++)
+                        if (keymap[index].scancode == scancode)
+                                break;
+
+                /* See if there is an unused hole in the map */
+                if (index >= keymap_size) {
+                        for (index = 0; index < keymap_size; index++) {
+                                if (keymap[index].keycode == KEY_RESERVED ||
+                                    keymap[index].keycode == KEY_UNKNOWN) {
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        return index;
+}
+
+static int legacy_dvb_usb_getkeycode(struct input_dev *dev,
+                                     struct input_keymap_entry *ke)
+{
+        struct dvb_usb_device *d = input_get_drvdata(dev);
+        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
+        unsigned int keymap_size = d->props.rc.legacy.rc_map_size;
+        unsigned int index;
+
+        index = legacy_dvb_usb_get_keymap_index(ke, keymap, keymap_size);
+        if (index >= keymap_size)
+                return -EINVAL;
+
+        ke->keycode = keymap[index].keycode;
+        if (ke->keycode == KEY_UNKNOWN)
+                ke->keycode = KEY_RESERVED;
+        ke->len = sizeof(keymap[index].scancode);
+        memcpy(&ke->scancode, &keymap[index].scancode, ke->len);
+        ke->index = index;
+
+        return 0;
+}
+
+static int legacy_dvb_usb_setkeycode(struct input_dev *dev,
+                                     const struct input_keymap_entry *ke,
+                                     unsigned int *old_keycode)
+{
+        struct dvb_usb_device *d = input_get_drvdata(dev);
+        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
+        unsigned int keymap_size = d->props.rc.legacy.rc_map_size;
+        unsigned int index;
+
+        index = legacy_dvb_usb_get_keymap_index(ke, keymap, keymap_size);
+        /*
+         * FIXME: Currently, it is not possible to increase the size of
+         * scancode table. For it to happen, one possibility
+         * would be to allocate a table with key_map_size + 1,
+         * copying data, appending the new key on it, and freeing
+         * the old one - or maybe just allocating some spare space
+         */
+        if (index >= keymap_size)
+                return -EINVAL;
+
+        *old_keycode = keymap[index].keycode;
+        keymap->keycode = ke->keycode;
+        __set_bit(ke->keycode, dev->keybit);
+
+        if (*old_keycode != KEY_RESERVED) {
+                __clear_bit(*old_keycode, dev->keybit);
+                for (index = 0; index < keymap_size; index++) {
+                        if (keymap[index].keycode == *old_keycode) {
+                                __set_bit(*old_keycode, dev->keybit);
+                                break;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+/* Remote-control poll function - called every dib->rc_query_interval ms to see
+ * whether the remote control has received anything.
+ *
+ * TODO: Fix the repeat rate of the input device.
+ */
+static void legacy_dvb_usb_read_remote_control(struct work_struct *work)
+{
+        struct dvb_usb_device *d =
+                container_of(work, struct dvb_usb_device, rc_query_work.work);
+        u32 event;
+        int state;
+
+        /* TODO: need a lock here.  We can simply skip checking for the remote control
+           if we're busy. */
+
+        /* when the parameter has been set to 1 via sysfs while the driver was running */
+        if (dvb_usb_disable_rc_polling)
+                return;
+
+        if (d->props.rc.legacy.rc_query(d,&event,&state)) {
+                err("error while querying for an remote control event.");
+                goto schedule;
+        }
+
+
+        switch (state) {
+                case REMOTE_NO_KEY_PRESSED:
+                        break;
+                case REMOTE_KEY_PRESSED:
+                        deb_rc("key pressed\n");
+                        d->last_event = event;
+                case REMOTE_KEY_REPEAT:
+                        deb_rc("key repeated\n");
+                        input_event(d->input_dev, EV_KEY, event, 1);
+                        input_sync(d->input_dev);
+                        input_event(d->input_dev, EV_KEY, d->last_event, 0);
+                        input_sync(d->input_dev);
+                        break;
+                default:
+                        break;
+        }
+
+/* improved repeat handling ???
+        switch (state) {
+                case REMOTE_NO_KEY_PRESSED:
+                        deb_rc("NO KEY PRESSED\n");
+                        if (d->last_state != REMOTE_NO_KEY_PRESSED) {
+                                deb_rc("releasing event %d\n",d->last_event);
+                                input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
+                                input_sync(d->rc_input_dev);
+                        }
+                        d->last_state = REMOTE_NO_KEY_PRESSED;
+                        d->last_event = 0;
+                        break;
+                case REMOTE_KEY_PRESSED:
+                        deb_rc("KEY PRESSED\n");
+                        deb_rc("pressing event %d\n",event);
+
+                        input_event(d->rc_input_dev, EV_KEY, event, 1);
+                        input_sync(d->rc_input_dev);
+
+                        d->last_event = event;
+                        d->last_state = REMOTE_KEY_PRESSED;
+                        break;
+                case REMOTE_KEY_REPEAT:
+                        deb_rc("KEY_REPEAT\n");
+                        if (d->last_state != REMOTE_NO_KEY_PRESSED) {
+                                deb_rc("repeating event %d\n",d->last_event);
+                                input_event(d->rc_input_dev, EV_KEY, d->last_event, 2);
+                                input_sync(d->rc_input_dev);
+                                d->last_state = REMOTE_KEY_REPEAT;
+                        }
+                default:
+                        break;
+        }
+*/
+
+schedule:
+        schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc.legacy.rc_interval));
+}
+
+static int legacy_dvb_usb_remote_init(struct dvb_usb_device *d)
+{
+        int i, err, rc_interval;
+        struct input_dev *input_dev;
+
+        input_dev = input_allocate_device();
+        if (!input_dev)
+                return -ENOMEM;
+
+        input_dev->evbit[0] = BIT_MASK(EV_KEY);
+        input_dev->name = "IR-receiver inside an USB DVB receiver";
+        input_dev->phys = d->rc_phys;
+        usb_to_input_id(d->udev, &input_dev->id);
+        input_dev->dev.parent = &d->udev->dev;
+        d->input_dev = input_dev;
+        d->rc_dev = NULL;
+
+        input_dev->getkeycode = legacy_dvb_usb_getkeycode;
+        input_dev->setkeycode = legacy_dvb_usb_setkeycode;
+
+        /* set the bits for the keys */
+        deb_rc("key map size: %d\n", d->props.rc.legacy.rc_map_size);
+        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
+                deb_rc("setting bit for event %d item %d\n",
+                        d->props.rc.legacy.rc_map_table[i].keycode, i);
+                set_bit(d->props.rc.legacy.rc_map_table[i].keycode, input_dev->keybit);
+        }
+
+        /* setting these two values to non-zero, we have to manage key repeats */
+        input_dev->rep[REP_PERIOD] = d->props.rc.legacy.rc_interval;
+        input_dev->rep[REP_DELAY]  = d->props.rc.legacy.rc_interval + 150;
+
+        input_set_drvdata(input_dev, d);
+
+        err = input_register_device(input_dev);
+        if (err)
+                input_free_device(input_dev);
+
+        rc_interval = d->props.rc.legacy.rc_interval;
+
+        INIT_DELAYED_WORK(&d->rc_query_work, legacy_dvb_usb_read_remote_control);
+
+        info("schedule remote query interval to %d msecs.", rc_interval);
+        schedule_delayed_work(&d->rc_query_work,
+                              msecs_to_jiffies(rc_interval));
+
+        d->state |= DVB_USB_STATE_REMOTE;
+
+        return err;
+}
+
+/* Remote-control poll function - called every dib->rc_query_interval ms to see
+ * whether the remote control has received anything.
+ *
+ * TODO: Fix the repeat rate of the input device.
+ */
+static void dvb_usb_read_remote_control(struct work_struct *work)
+{
+        struct dvb_usb_device *d =
+                container_of(work, struct dvb_usb_device, rc_query_work.work);
+        int err;
+
+        /* TODO: need a lock here.  We can simply skip checking for the remote control
+           if we're busy. */
+
+        /* when the parameter has been set to 1 via sysfs while the
+         * driver was running, or when bulk mode is enabled after IR init
+         */
+        if (dvb_usb_disable_rc_polling || d->props.rc.core.bulk_mode)
+                return;
+
+        err = d->props.rc.core.rc_query(d);
+        if (err)
+                err("error %d while querying for an remote control event.", err);
+
+        schedule_delayed_work(&d->rc_query_work,
+                              msecs_to_jiffies(d->props.rc.core.rc_interval));
+}
+
+static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
+{
+        int err, rc_interval;
+        struct rc_dev *dev;
+
+        dev = rc_allocate_device();
+        if (!dev)
+                return -ENOMEM;
+
+        dev->driver_name = d->props.rc.core.module_name;
+        dev->map_name = d->props.rc.core.rc_codes;
+        dev->change_protocol = d->props.rc.core.change_protocol;
+        dev->allowed_protos = d->props.rc.core.allowed_protos;
+        dev->driver_type = d->props.rc.core.driver_type;
+        usb_to_input_id(d->udev, &dev->input_id);
+        dev->input_name = "IR-receiver inside an USB DVB receiver";
+        dev->input_phys = d->rc_phys;
+        dev->dev.parent = &d->udev->dev;
+        dev->priv = d;
+
+        err = rc_register_device(dev);
+        if (err < 0) {
+                rc_free_device(dev);
+                return err;
+        }
+
+        d->input_dev = NULL;
+        d->rc_dev = dev;
+
+        if (!d->props.rc.core.rc_query || d->props.rc.core.bulk_mode)
+                return 0;
+
+        /* Polling mode - initialize a work queue for handling it */
+        INIT_DELAYED_WORK(&d->rc_query_work, dvb_usb_read_remote_control);
+
+        rc_interval = d->props.rc.core.rc_interval;
+
+        info("schedule remote query interval to %d msecs.", rc_interval);
+        schedule_delayed_work(&d->rc_query_work,
+                              msecs_to_jiffies(rc_interval));
+
+        return 0;
+}
+
+int dvb_usb_remote_init(struct dvb_usb_device *d)
+{
+        int err;
+
+        if (dvb_usb_disable_rc_polling)
+                return 0;
+
+        if (d->props.rc.legacy.rc_map_table && d->props.rc.legacy.rc_query)
+                d->props.rc.mode = DVB_RC_LEGACY;
+        else if (d->props.rc.core.rc_codes)
+                d->props.rc.mode = DVB_RC_CORE;
+        else
+                return 0;
+
+        usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
+        strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
+
+        /* Start the remote-control polling. */
+        if (d->props.rc.legacy.rc_interval < 40)
+                d->props.rc.legacy.rc_interval = 100; /* default */
+
+        if (d->props.rc.mode == DVB_RC_LEGACY)
+                err = legacy_dvb_usb_remote_init(d);
+        else
+                err = rc_core_dvb_usb_remote_init(d);
+        if (err)
+                return err;
+
+        d->state |= DVB_USB_STATE_REMOTE;
+
+        return 0;
+}
+
+int dvb_usb_remote_exit(struct dvb_usb_device *d)
+{
+        if (d->state & DVB_USB_STATE_REMOTE) {
+                cancel_delayed_work_sync(&d->rc_query_work);
+                if (d->props.rc.mode == DVB_RC_LEGACY)
+                        input_unregister_device(d->input_dev);
+                else
+                        rc_unregister_device(d->rc_dev);
+        }
+        d->state &= ~DVB_USB_STATE_REMOTE;
+        return 0;
+}
+
+#define DVB_USB_RC_NEC_EMPTY           0x00
+#define DVB_USB_RC_NEC_KEY_PRESSED     0x01
+#define DVB_USB_RC_NEC_KEY_REPEATED    0x02
+int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *d,
+                u8 keybuf[5], u32 *event, int *state)
+{
+        int i;
+        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
+        *event = 0;
+        *state = REMOTE_NO_KEY_PRESSED;
+        switch (keybuf[0]) {
+                case DVB_USB_RC_NEC_EMPTY:
+                        break;
+                case DVB_USB_RC_NEC_KEY_PRESSED:
+                        if ((u8) ~keybuf[1] != keybuf[2] ||
+                                (u8) ~keybuf[3] != keybuf[4]) {
+                                deb_err("remote control checksum failed.\n");
+                                break;
+                        }
+                        /* See if we can match the raw key code. */
+                        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++)
+                                if (rc5_custom(&keymap[i]) == keybuf[1] &&
+                                        rc5_data(&keymap[i]) == keybuf[3]) {
+                                        *event = keymap[i].keycode;
+                                        *state = REMOTE_KEY_PRESSED;
+                                        return 0;
+                                }
+                        deb_err("key mapping failed - no appropriate key found in keymapping\n");
+                        break;
+                case DVB_USB_RC_NEC_KEY_REPEATED:
+                        *state = REMOTE_KEY_REPEAT;
+                        break;
+                default:
+                        deb_err("unknown type of remote status: %d\n",keybuf[0]);
+                        break;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(dvb_usb_nec_rc_key_to_event);
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-urb.c b/drivers/media/dvb/dvb-usb/dvb-usb-urb.c
new file mode 100644
index 00000000000..bb46ba6a357
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-urb.c
@@ -0,0 +1,97 @@
+/* dvb-usb-urb.c is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
+ * see dvb-usb-init.c for copyright information.
+ *
+ * This file keeps functions for initializing and handling the
+ * USB and URB stuff.
+ */
+#include "dvb-usb-common.h"
+
+int dvb_usb_generic_rw(struct dvb_usb_device *d, u8 *wbuf, u16 wlen, u8 *rbuf,
+        u16 rlen, int delay_ms)
+{
+        int actlen,ret = -ENOMEM;
+
+        if (!d || wbuf == NULL || wlen == 0)
+                return -EINVAL;
+
+        if (d->props.generic_bulk_ctrl_endpoint == 0) {
+                err("endpoint for generic control not specified.");
+                return -EINVAL;
+        }
+
+        if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
+                return ret;
+
+        deb_xfer(">>> ");
+        debug_dump(wbuf,wlen,deb_xfer);
+
+        ret = usb_bulk_msg(d->udev,usb_sndbulkpipe(d->udev,
+                        d->props.generic_bulk_ctrl_endpoint), wbuf,wlen,&actlen,
+                        2000);
+
+        if (ret)
+                err("bulk message failed: %d (%d/%d)",ret,wlen,actlen);
+        else
+                ret = actlen != wlen ? -1 : 0;
+
+        /* an answer is expected, and no error before */
+        if (!ret && rbuf && rlen) {
+                if (delay_ms)
+                        msleep(delay_ms);
+
+                ret = usb_bulk_msg(d->udev,usb_rcvbulkpipe(d->udev,
+                                d->props.generic_bulk_ctrl_endpoint_response ?
+                                d->props.generic_bulk_ctrl_endpoint_response :
+                                d->props.generic_bulk_ctrl_endpoint),rbuf,rlen,&actlen,
+                                2000);
+
+                if (ret)
+                        err("recv bulk message failed: %d",ret);
+                else {
+                        deb_xfer("<<< ");
+                        debug_dump(rbuf,actlen,deb_xfer);
+                }
+        }
+
+        mutex_unlock(&d->usb_mutex);
+        return ret;
+}
+EXPORT_SYMBOL(dvb_usb_generic_rw);
+
+int dvb_usb_generic_write(struct dvb_usb_device *d, u8 *buf, u16 len)
+{
+        return dvb_usb_generic_rw(d,buf,len,NULL,0,0);
+}
+EXPORT_SYMBOL(dvb_usb_generic_write);
+
+static void dvb_usb_data_complete(struct usb_data_stream *stream, u8 *buffer, size_t length)
+{
+        struct dvb_usb_adapter *adap = stream->user_priv;
+        if (adap->feedcount > 0 && adap->state & DVB_USB_ADAP_STATE_DVB)
+                dvb_dmx_swfilter(&adap->demux, buffer, length);
+}
+
+static void dvb_usb_data_complete_204(struct usb_data_stream *stream, u8 *buffer, size_t length)
+{
+        struct dvb_usb_adapter *adap = stream->user_priv;
+        if (adap->feedcount > 0 && adap->state & DVB_USB_ADAP_STATE_DVB)
+                dvb_dmx_swfilter_204(&adap->demux, buffer, length);
+}
+
+int dvb_usb_adapter_stream_init(struct dvb_usb_adapter *adap)
+{
+        adap->stream.udev      = adap->dev->udev;
+        if (adap->props.caps & DVB_USB_ADAP_RECEIVES_204_BYTE_TS)
+                adap->stream.complete = dvb_usb_data_complete_204;
+        else
+        adap->stream.complete  = dvb_usb_data_complete;
+        adap->stream.user_priv = adap;
+        return usb_urb_init(&adap->stream, &adap->props.stream);
+}
+
+int dvb_usb_adapter_stream_exit(struct dvb_usb_adapter *adap)
+{
+        return usb_urb_exit(&adap->stream);
+}
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb.h b/drivers/media/dvb/dvb-usb/dvb-usb.h
new file mode 100644
index 00000000000..7d35d078342
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dvb-usb.h
@@ -0,0 +1,463 @@
+/* dvb-usb.h is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
+ * see dvb-usb-init.c for copyright information.
+ *
+ * the headerfile, all dvb-usb-drivers have to include.
+ *
+ * TODO: clean-up the structures for unused fields and update the comments
+ */
+#ifndef __DVB_USB_H__
+#define __DVB_USB_H__
+
+#include <linux/input.h>
+#include <linux/usb.h>
+#include <linux/firmware.h>
+#include <linux/mutex.h>
+#include <media/rc-core.h>
+
+#include "dvb_frontend.h"
+#include "dvb_demux.h"
+#include "dvb_net.h"
+#include "dmxdev.h"
+
+#include "dvb-pll.h"
+
+#include "dvb-usb-ids.h"
+
+/* debug */
+#ifdef CONFIG_DVB_USB_DEBUG
+#define dprintk(var,level,args...) \
+            do { if ((var & level)) { printk(args); } } while (0)
+
+#define debug_dump(b,l,func) {\
+        int loop_; \
+        for (loop_ = 0; loop_ < l; loop_++) func("%02x ", b[loop_]); \
+        func("\n");\
+}
+#define DVB_USB_DEBUG_STATUS
+#else
+#define dprintk(args...)
+#define debug_dump(b,l,func)
+
+#define DVB_USB_DEBUG_STATUS " (debugging is not enabled)"
+
+#endif
+
+/* generic log methods - taken from usb.h */
+#ifndef DVB_USB_LOG_PREFIX
+ #define DVB_USB_LOG_PREFIX "dvb-usb (please define a log prefix)"
+#endif
+
+#undef err
+#define err(format, arg...)  printk(KERN_ERR     DVB_USB_LOG_PREFIX ": " format "\n" , ## arg)
+#undef info
+#define info(format, arg...) printk(KERN_INFO    DVB_USB_LOG_PREFIX ": " format "\n" , ## arg)
+#undef warn
+#define warn(format, arg...) printk(KERN_WARNING DVB_USB_LOG_PREFIX ": " format "\n" , ## arg)
+
+/**
+ * struct dvb_usb_device_description - name and its according USB IDs
+ * @name: real name of the box, regardless which DVB USB device class is in use
+ * @cold_ids: array of struct usb_device_id which describe the device in
+ *  pre-firmware state
+ * @warm_ids: array of struct usb_device_id which describe the device in
+ *  post-firmware state
+ *
+ * Each DVB USB device class can have one or more actual devices, this struct
+ * assigns a name to it.
+ */
+struct dvb_usb_device_description {
+        const char *name;
+
+#define DVB_USB_ID_MAX_NUM 15
+        struct usb_device_id *cold_ids[DVB_USB_ID_MAX_NUM];
+        struct usb_device_id *warm_ids[DVB_USB_ID_MAX_NUM];
+};
+
+static inline u8 rc5_custom(struct rc_map_table *key)
+{
+        return (key->scancode >> 8) & 0xff;
+}
+
+static inline u8 rc5_data(struct rc_map_table *key)
+{
+        return key->scancode & 0xff;
+}
+
+static inline u16 rc5_scan(struct rc_map_table *key)
+{
+        return key->scancode & 0xffff;
+}
+
+struct dvb_usb_device;
+struct dvb_usb_adapter;
+struct usb_data_stream;
+
+/**
+ * Properties of USB streaming - TODO this structure should be somewhere else
+ * describes the kind of USB transfer used for data-streaming.
+ *  (BULK or ISOC)
+ */
+struct usb_data_stream_properties {
+#define USB_BULK  1
+#define USB_ISOC  2
+        int type;
+        int count;
+        int endpoint;
+
+        union {
+                struct {
+                        int buffersize; /* per URB */
+                } bulk;
+                struct {
+                        int framesperurb;
+                        int framesize;
+                        int interval;
+                } isoc;
+        } u;
+};
+
+/**
+ * struct dvb_usb_adapter_properties - properties of a dvb-usb-adapter.
+ *    A DVB-USB-Adapter is basically a dvb_adapter which is present on a USB-device.
+ * @caps: capabilities of the DVB USB device.
+ * @pid_filter_count: number of PID filter position in the optional hardware
+ *  PID-filter.
+ * @streaming_ctrl: called to start and stop the MPEG2-TS streaming of the
+ *  device (not URB submitting/killing).
+ * @pid_filter_ctrl: called to en/disable the PID filter, if any.
+ * @pid_filter: called to set/unset a PID for filtering.
+ * @frontend_attach: called to attach the possible frontends (fill fe-field
+ *  of struct dvb_usb_device).
+ * @tuner_attach: called to attach the correct tuner and to fill pll_addr,
+ *  pll_desc and pll_init_buf of struct dvb_usb_device).
+ * @stream: configuration of the USB streaming
+ */
+struct dvb_usb_adapter_properties {
+#define DVB_USB_ADAP_HAS_PID_FILTER               0x01
+#define DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF 0x02
+#define DVB_USB_ADAP_NEED_PID_FILTERING           0x04
+#define DVB_USB_ADAP_RECEIVES_204_BYTE_TS         0x08
+        int caps;
+        int pid_filter_count;
+
+        int (*streaming_ctrl)  (struct dvb_usb_adapter *, int);
+        int (*pid_filter_ctrl) (struct dvb_usb_adapter *, int);
+        int (*pid_filter)      (struct dvb_usb_adapter *, int, u16, int);
+
+        int (*frontend_attach) (struct dvb_usb_adapter *);
+        int (*tuner_attach)    (struct dvb_usb_adapter *);
+
+        struct usb_data_stream_properties stream;
+
+        int size_of_priv;
+
+        int (*fe_ioctl_override) (struct dvb_frontend *,
+                                  unsigned int, void *, unsigned int);
+};
+
+/**
+ * struct dvb_rc_legacy - old properties of remote controller
+ * @rc_map_table: a hard-wired array of struct rc_map_table (NULL to disable
+ *  remote control handling).
+ * @rc_map_size: number of items in @rc_map_table.
+ * @rc_query: called to query an event event.
+ * @rc_interval: time in ms between two queries.
+ */
+struct dvb_rc_legacy {
+/* remote control properties */
+#define REMOTE_NO_KEY_PRESSED      0x00
+#define REMOTE_KEY_PRESSED         0x01
+#define REMOTE_KEY_REPEAT          0x02
+        struct rc_map_table  *rc_map_table;
+        int rc_map_size;
+        int (*rc_query) (struct dvb_usb_device *, u32 *, int *);
+        int rc_interval;
+};
+
+/**
+ * struct dvb_rc properties of remote controller, using rc-core
+ * @rc_codes: name of rc codes table
+ * @protocol: type of protocol(s) currently used by the driver
+ * @allowed_protos: protocol(s) supported by the driver
+ * @driver_type: Used to point if a device supports raw mode
+ * @change_protocol: callback to change protocol
+ * @rc_query: called to query an event event.
+ * @rc_interval: time in ms between two queries.
+ * @bulk_mode: device supports bulk mode for RC (disable polling mode)
+ */
+struct dvb_rc {
+        char *rc_codes;
+        u64 protocol;
+        u64 allowed_protos;
+        enum rc_driver_type driver_type;
+        int (*change_protocol)(struct rc_dev *dev, u64 rc_type);
+        char *module_name;
+        int (*rc_query) (struct dvb_usb_device *d);
+        int rc_interval;
+        bool bulk_mode;                         /* uses bulk mode */
+};
+
+/**
+ * enum dvb_usb_mode - Specifies if it is using a legacy driver or a new one
+ *                     based on rc-core
+ * This is initialized/used only inside dvb-usb-remote.c.
+ * It shouldn't be set by the drivers.
+ */
+enum dvb_usb_mode {
+        DVB_RC_LEGACY,
+        DVB_RC_CORE,
+};
+
+/**
+ * struct dvb_usb_device_properties - properties of a dvb-usb-device
+ * @usb_ctrl: which USB device-side controller is in use. Needed for firmware
+ *  download.
+ * @firmware: name of the firmware file.
+ * @download_firmware: called to download the firmware when the usb_ctrl is
+ *  DEVICE_SPECIFIC.
+ * @no_reconnect: device doesn't do a reconnect after downloading the firmware,
+ *  so do the warm initialization right after it
+ *
+ * @size_of_priv: how many bytes shall be allocated for the private field
+ *  of struct dvb_usb_device.
+ *
+ * @power_ctrl: called to enable/disable power of the device.
+ * @read_mac_address: called to read the MAC address of the device.
+ * @identify_state: called to determine the state (cold or warm), when it
+ *  is not distinguishable by the USB IDs.
+ *
+ * @rc: remote controller properties
+ *
+ * @i2c_algo: i2c_algorithm if the device has I2CoverUSB.
+ *
+ * @generic_bulk_ctrl_endpoint: most of the DVB USB devices have a generic
+ *  endpoint which received control messages with bulk transfers. When this
+ *  is non-zero, one can use dvb_usb_generic_rw and dvb_usb_generic_write-
+ *  helper functions.
+ *
+ * @generic_bulk_ctrl_endpoint_response: some DVB USB devices use a separate
+ *  endpoint for responses to control messages sent with bulk transfers via
+ *  the generic_bulk_ctrl_endpoint. When this is non-zero, this will be used
+ *  instead of the generic_bulk_ctrl_endpoint when reading usb responses in
+ *  the dvb_usb_generic_rw helper function.
+ *
+ * @num_device_descs: number of struct dvb_usb_device_description in @devices
+ * @devices: array of struct dvb_usb_device_description compatibles with these
+ *  properties.
+ */
+#define MAX_NO_OF_ADAPTER_PER_DEVICE 2
+struct dvb_usb_device_properties {
+
+#define DVB_USB_IS_AN_I2C_ADAPTER            0x01
+        int caps;
+
+#define DEVICE_SPECIFIC 0
+#define CYPRESS_AN2135  1
+#define CYPRESS_AN2235  2
+#define CYPRESS_FX2     3
+        int        usb_ctrl;
+        int        (*download_firmware) (struct usb_device *, const struct firmware *);
+        const char *firmware;
+        int        no_reconnect;
+
+        int size_of_priv;
+
+        int num_adapters;
+        struct dvb_usb_adapter_properties adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
+
+        int (*power_ctrl)       (struct dvb_usb_device *, int);
+        int (*read_mac_address) (struct dvb_usb_device *, u8 []);
+        int (*identify_state)   (struct usb_device *, struct dvb_usb_device_properties *,
+                        struct dvb_usb_device_description **, int *);
+
+        struct {
+                enum dvb_usb_mode mode; /* Drivers shouldn't touch on it */
+                struct dvb_rc_legacy legacy;
+                struct dvb_rc core;
+        } rc;
+
+        struct i2c_algorithm *i2c_algo;
+
+        int generic_bulk_ctrl_endpoint;
+        int generic_bulk_ctrl_endpoint_response;
+
+        int num_device_descs;
+        struct dvb_usb_device_description devices[12];
+};
+
+/**
+ * struct usb_data_stream - generic object of an USB stream
+ * @buf_num: number of buffer allocated.
+ * @buf_size: size of each buffer in buf_list.
+ * @buf_list: array containing all allocate buffers for streaming.
+ * @dma_addr: list of dma_addr_t for each buffer in buf_list.
+ *
+ * @urbs_initialized: number of URBs initialized.
+ * @urbs_submitted: number of URBs submitted.
+ */
+#define MAX_NO_URBS_FOR_DATA_STREAM 10
+struct usb_data_stream {
+        struct usb_device                 *udev;
+        struct usb_data_stream_properties  props;
+
+#define USB_STATE_INIT    0x00
+#define USB_STATE_URB_BUF 0x01
+        int state;
+
+        void (*complete) (struct usb_data_stream *, u8 *, size_t);
+
+        struct urb    *urb_list[MAX_NO_URBS_FOR_DATA_STREAM];
+        int            buf_num;
+        unsigned long  buf_size;
+        u8            *buf_list[MAX_NO_URBS_FOR_DATA_STREAM];
+        dma_addr_t     dma_addr[MAX_NO_URBS_FOR_DATA_STREAM];
+
+        int urbs_initialized;
+        int urbs_submitted;
+
+        void *user_priv;
+};
+
+/**
+ * struct dvb_usb_adapter - a DVB adapter on a USB device
+ * @id: index of this adapter (starting with 0).
+ *
+ * @feedcount: number of reqested feeds (used for streaming-activation)
+ * @pid_filtering: is hardware pid_filtering used or not.
+ *
+ * @pll_addr: I2C address of the tuner for programming
+ * @pll_init: array containing the initialization buffer
+ * @pll_desc: pointer to the appropriate struct dvb_pll_desc
+ * @tuner_pass_ctrl: called to (de)activate tuner passthru of the demod or the board
+ *
+ * @dvb_adap: device's dvb_adapter.
+ * @dmxdev: device's dmxdev.
+ * @demux: device's software demuxer.
+ * @dvb_net: device's dvb_net interfaces.
+ * @dvb_frontend: device's frontend.
+ * @max_feed_count: how many feeds can be handled simultaneously by this
+ *  device
+ *
+ * @fe_init:  rerouted frontend-init (wakeup) function.
+ * @fe_sleep: rerouted frontend-sleep function.
+ *
+ * @stream: the usb data stream.
+ */
+struct dvb_usb_adapter {
+        struct dvb_usb_device *dev;
+        struct dvb_usb_adapter_properties props;
+
+#define DVB_USB_ADAP_STATE_INIT 0x000
+#define DVB_USB_ADAP_STATE_DVB  0x001
+        int state;
+
+        u8  id;
+
+        int feedcount;
+        int pid_filtering;
+
+        /* dvb */
+        struct dvb_adapter   dvb_adap;
+        struct dmxdev        dmxdev;
+        struct dvb_demux     demux;
+        struct dvb_net       dvb_net;
+        struct dvb_frontend *fe;
+        int                  max_feed_count;
+
+        int (*fe_init)  (struct dvb_frontend *);
+        int (*fe_sleep) (struct dvb_frontend *);
+
+        struct usb_data_stream stream;
+
+        void *priv;
+};
+
+/**
+ * struct dvb_usb_device - object of a DVB USB device
+ * @props: copy of the struct dvb_usb_properties this device belongs to.
+ * @desc: pointer to the device's struct dvb_usb_device_description.
+ * @state: initialization and runtime state of the device.
+ *
+ * @powered: indicated whether the device is power or not.
+ *  Powered is in/decremented for each call to modify the state.
+ * @udev: pointer to the device's struct usb_device.
+ *
+ * @usb_mutex: semaphore of USB control messages (reading needs two messages)
+ * @i2c_mutex: semaphore for i2c-transfers
+ *
+ * @i2c_adap: device's i2c_adapter if it uses I2CoverUSB
+ *
+ * @rc_dev: rc device for the remote control (rc-core mode)
+ * @input_dev: input device for the remote control (legacy mode)
+ * @rc_query_work: struct work_struct frequent rc queries
+ * @last_event: last triggered event
+ * @last_state: last state (no, pressed, repeat)
+ * @owner: owner of the dvb_adapter
+ * @priv: private data of the actual driver (allocate by dvb-usb, size defined
+ *  in size_of_priv of dvb_usb_properties).
+ */
+struct dvb_usb_device {
+        struct dvb_usb_device_properties props;
+        struct dvb_usb_device_description *desc;
+
+        struct usb_device *udev;
+
+#define DVB_USB_STATE_INIT        0x000
+#define DVB_USB_STATE_I2C         0x001
+#define DVB_USB_STATE_DVB         0x002
+#define DVB_USB_STATE_REMOTE      0x004
+        int state;
+
+        int powered;
+
+        /* locking */
+        struct mutex usb_mutex;
+
+        /* i2c */
+        struct mutex i2c_mutex;
+        struct i2c_adapter i2c_adap;
+
+        int                    num_adapters_initialized;
+        struct dvb_usb_adapter adapter[MAX_NO_OF_ADAPTER_PER_DEVICE];
+
+        /* remote control */
+        struct rc_dev *rc_dev;
+        struct input_dev *input_dev;
+        char rc_phys[64];
+        struct delayed_work rc_query_work;
+        u32 last_event;
+        int last_state;
+
+        struct module *owner;
+
+        void *priv;
+};
+
+extern int dvb_usb_device_init(struct usb_interface *,
+                               struct dvb_usb_device_properties *,
+                               struct module *, struct dvb_usb_device **,
+                               short *adapter_nums);
+extern void dvb_usb_device_exit(struct usb_interface *);
+
+/* the generic read/write method for device control */
+extern int dvb_usb_generic_rw(struct dvb_usb_device *, u8 *, u16, u8 *, u16,int);
+extern int dvb_usb_generic_write(struct dvb_usb_device *, u8 *, u16);
+
+/* commonly used remote control parsing */
+extern int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *, u8[], u32 *, int *);
+
+/* commonly used firmware download types and function */
+struct hexline {
+        u8 len;
+        u32 addr;
+        u8 type;
+        u8 data[255];
+        u8 chk;
+};
+extern int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type);
+extern int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos);
+
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/dw2102.c b/drivers/media/dvb/dvb-usb/dw2102.c
new file mode 100644
index 00000000000..058b2318abe
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dw2102.c
@@ -0,0 +1,1940 @@
+/* DVB USB framework compliant Linux driver for the
+ *      DVBWorld DVB-S 2101, 2102, DVB-S2 2104, DVB-C 3101,
+ *      TeVii S600, S630, S650, S660, S480,
+ *      Prof 1100, 7500,
+ *      Geniatech SU3000 Cards
+ * Copyright (C) 2008-2011 Igor M. Liplianin (liplianin@me.by)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dw2102.h"
+#include "si21xx.h"
+#include "stv0299.h"
+#include "z0194a.h"
+#include "stv0288.h"
+#include "stb6000.h"
+#include "eds1547.h"
+#include "cx24116.h"
+#include "tda1002x.h"
+#include "mt312.h"
+#include "zl10039.h"
+#include "ds3000.h"
+#include "stv0900.h"
+#include "stv6110.h"
+#include "stb6100.h"
+#include "stb6100_proc.h"
+
+#ifndef USB_PID_DW2102
+#define USB_PID_DW2102 0x2102
+#endif
+
+#ifndef USB_PID_DW2104
+#define USB_PID_DW2104 0x2104
+#endif
+
+#ifndef USB_PID_DW3101
+#define USB_PID_DW3101 0x3101
+#endif
+
+#ifndef USB_PID_CINERGY_S
+#define USB_PID_CINERGY_S 0x0064
+#endif
+
+#ifndef USB_PID_TEVII_S630
+#define USB_PID_TEVII_S630 0xd630
+#endif
+
+#ifndef USB_PID_TEVII_S650
+#define USB_PID_TEVII_S650 0xd650
+#endif
+
+#ifndef USB_PID_TEVII_S660
+#define USB_PID_TEVII_S660 0xd660
+#endif
+
+#ifndef USB_PID_TEVII_S480_1
+#define USB_PID_TEVII_S480_1 0xd481
+#endif
+
+#ifndef USB_PID_TEVII_S480_2
+#define USB_PID_TEVII_S480_2 0xd482
+#endif
+
+#ifndef USB_PID_PROF_1100
+#define USB_PID_PROF_1100 0xb012
+#endif
+
+#define DW210X_READ_MSG 0
+#define DW210X_WRITE_MSG 1
+
+#define REG_1F_SYMBOLRATE_BYTE0 0x1f
+#define REG_20_SYMBOLRATE_BYTE1 0x20
+#define REG_21_SYMBOLRATE_BYTE2 0x21
+/* on my own*/
+#define DW2102_VOLTAGE_CTRL (0x1800)
+#define SU3000_STREAM_CTRL (0x1900)
+#define DW2102_RC_QUERY (0x1a00)
+#define DW2102_LED_CTRL (0x1b00)
+
+#define err_str "did not find the firmware file. (%s) " \
+                "Please see linux/Documentation/dvb/ for more details " \
+                "on firmware-problems."
+
+struct rc_map_dvb_usb_table_table {
+        struct rc_map_table *rc_keys;
+        int rc_keys_size;
+};
+
+struct su3000_state {
+        u8 initialized;
+};
+
+struct s6x0_state {
+        int (*old_set_voltage)(struct dvb_frontend *f, fe_sec_voltage_t v);
+};
+
+/* debug */
+static int dvb_usb_dw2102_debug;
+module_param_named(debug, dvb_usb_dw2102_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info 2=xfer 4=rc(or-able))."
+                                                DVB_USB_DEBUG_STATUS);
+
+/* keymaps */
+static int ir_keymap;
+module_param_named(keymap, ir_keymap, int, 0644);
+MODULE_PARM_DESC(keymap, "set keymap 0=default 1=dvbworld 2=tevii 3=tbs  ..."
+                        " 256=none");
+
+/* demod probe */
+static int demod_probe = 1;
+module_param_named(demod, demod_probe, int, 0644);
+MODULE_PARM_DESC(demod, "demod to probe (1=cx24116 2=stv0903+stv6110 "
+                        "4=stv0903+stb6100(or-able)).");
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int dw210x_op_rw(struct usb_device *dev, u8 request, u16 value,
+                        u16 index, u8 * data, u16 len, int flags)
+{
+        int ret;
+        u8 *u8buf;
+        unsigned int pipe = (flags == DW210X_READ_MSG) ?
+                                usb_rcvctrlpipe(dev, 0) : usb_sndctrlpipe(dev, 0);
+        u8 request_type = (flags == DW210X_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;
+
+        u8buf = kmalloc(len, GFP_KERNEL);
+        if (!u8buf)
+                return -ENOMEM;
+
+
+        if (flags == DW210X_WRITE_MSG)
+                memcpy(u8buf, data, len);
+        ret = usb_control_msg(dev, pipe, request, request_type | USB_TYPE_VENDOR,
+                                value, index , u8buf, len, 2000);
+
+        if (flags == DW210X_READ_MSG)
+                memcpy(data, u8buf, len);
+
+        kfree(u8buf);
+        return ret;
+}
+
+/* I2C */
+static int dw2102_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i = 0, ret = 0;
+        u8 buf6[] = {0x2c, 0x05, 0xc0, 0, 0, 0, 0};
+        u16 value;
+
+        if (!d)
+                return -ENODEV;
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        switch (num) {
+        case 2:
+                /* read stv0299 register */
+                value = msg[0].buf[0];/* register */
+                for (i = 0; i < msg[1].len; i++) {
+                        ret = dw210x_op_rw(d->udev, 0xb5, value + i, 0,
+                                        buf6, 2, DW210X_READ_MSG);
+                        msg[1].buf[i] = buf6[0];
+                }
+                break;
+        case 1:
+                switch (msg[0].addr) {
+                case 0x68:
+                        /* write to stv0299 register */
+                        buf6[0] = 0x2a;
+                        buf6[1] = msg[0].buf[0];
+                        buf6[2] = msg[0].buf[1];
+                        ret = dw210x_op_rw(d->udev, 0xb2, 0, 0,
+                                        buf6, 3, DW210X_WRITE_MSG);
+                        break;
+                case 0x60:
+                        if (msg[0].flags == 0) {
+                        /* write to tuner pll */
+                                buf6[0] = 0x2c;
+                                buf6[1] = 5;
+                                buf6[2] = 0xc0;
+                                buf6[3] = msg[0].buf[0];
+                                buf6[4] = msg[0].buf[1];
+                                buf6[5] = msg[0].buf[2];
+                                buf6[6] = msg[0].buf[3];
+                                ret = dw210x_op_rw(d->udev, 0xb2, 0, 0,
+                                                buf6, 7, DW210X_WRITE_MSG);
+                        } else {
+                        /* read from tuner */
+                                ret = dw210x_op_rw(d->udev, 0xb5, 0, 0,
+                                                buf6, 1, DW210X_READ_MSG);
+                                msg[0].buf[0] = buf6[0];
+                        }
+                        break;
+                case (DW2102_RC_QUERY):
+                        ret  = dw210x_op_rw(d->udev, 0xb8, 0, 0,
+                                        buf6, 2, DW210X_READ_MSG);
+                        msg[0].buf[0] = buf6[0];
+                        msg[0].buf[1] = buf6[1];
+                        break;
+                case (DW2102_VOLTAGE_CTRL):
+                        buf6[0] = 0x30;
+                        buf6[1] = msg[0].buf[0];
+                        ret = dw210x_op_rw(d->udev, 0xb2, 0, 0,
+                                        buf6, 2, DW210X_WRITE_MSG);
+                        break;
+                }
+
+                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return num;
+}
+
+static int dw2102_serit_i2c_transfer(struct i2c_adapter *adap,
+                                                struct i2c_msg msg[], int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int ret = 0;
+        u8 buf6[] = {0, 0, 0, 0, 0, 0, 0};
+
+        if (!d)
+                return -ENODEV;
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        switch (num) {
+        case 2:
+                /* read si2109 register by number */
+                buf6[0] = msg[0].addr << 1;
+                buf6[1] = msg[0].len;
+                buf6[2] = msg[0].buf[0];
+                ret = dw210x_op_rw(d->udev, 0xc2, 0, 0,
+                                buf6, msg[0].len + 2, DW210X_WRITE_MSG);
+                /* read si2109 register */
+                ret = dw210x_op_rw(d->udev, 0xc3, 0xd0, 0,
+                                buf6, msg[1].len + 2, DW210X_READ_MSG);
+                memcpy(msg[1].buf, buf6 + 2, msg[1].len);
+
+                break;
+        case 1:
+                switch (msg[0].addr) {
+                case 0x68:
+                        /* write to si2109 register */
+                        buf6[0] = msg[0].addr << 1;
+                        buf6[1] = msg[0].len;
+                        memcpy(buf6 + 2, msg[0].buf, msg[0].len);
+                        ret = dw210x_op_rw(d->udev, 0xc2, 0, 0, buf6,
+                                        msg[0].len + 2, DW210X_WRITE_MSG);
+                        break;
+                case(DW2102_RC_QUERY):
+                        ret  = dw210x_op_rw(d->udev, 0xb8, 0, 0,
+                                        buf6, 2, DW210X_READ_MSG);
+                        msg[0].buf[0] = buf6[0];
+                        msg[0].buf[1] = buf6[1];
+                        break;
+                case(DW2102_VOLTAGE_CTRL):
+                        buf6[0] = 0x30;
+                        buf6[1] = msg[0].buf[0];
+                        ret = dw210x_op_rw(d->udev, 0xb2, 0, 0,
+                                        buf6, 2, DW210X_WRITE_MSG);
+                        break;
+                }
+                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return num;
+}
+
+static int dw2102_earda_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int ret = 0;
+
+        if (!d)
+                return -ENODEV;
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        switch (num) {
+        case 2: {
+                /* read */
+                /* first write first register number */
+                u8 ibuf[msg[1].len + 2], obuf[3];
+                obuf[0] = msg[0].addr << 1;
+                obuf[1] = msg[0].len;
+                obuf[2] = msg[0].buf[0];
+                ret = dw210x_op_rw(d->udev, 0xc2, 0, 0,
+                                obuf, msg[0].len + 2, DW210X_WRITE_MSG);
+                /* second read registers */
+                ret = dw210x_op_rw(d->udev, 0xc3, 0xd1 , 0,
+                                ibuf, msg[1].len + 2, DW210X_READ_MSG);
+                memcpy(msg[1].buf, ibuf + 2, msg[1].len);
+
+                break;
+        }
+        case 1:
+                switch (msg[0].addr) {
+                case 0x68: {
+                        /* write to register */
+                        u8 obuf[msg[0].len + 2];
+                        obuf[0] = msg[0].addr << 1;
+                        obuf[1] = msg[0].len;
+                        memcpy(obuf + 2, msg[0].buf, msg[0].len);
+                        ret = dw210x_op_rw(d->udev, 0xc2, 0, 0,
+                                        obuf, msg[0].len + 2, DW210X_WRITE_MSG);
+                        break;
+                }
+                case 0x61: {
+                        /* write to tuner */
+                        u8 obuf[msg[0].len + 2];
+                        obuf[0] = msg[0].addr << 1;
+                        obuf[1] = msg[0].len;
+                        memcpy(obuf + 2, msg[0].buf, msg[0].len);
+                        ret = dw210x_op_rw(d->udev, 0xc2, 0, 0,
+                                        obuf, msg[0].len + 2, DW210X_WRITE_MSG);
+                        break;
+                }
+                case(DW2102_RC_QUERY): {
+                        u8 ibuf[2];
+                        ret  = dw210x_op_rw(d->udev, 0xb8, 0, 0,
+                                        ibuf, 2, DW210X_READ_MSG);
+                        memcpy(msg[0].buf, ibuf , 2);
+                        break;
+                }
+                case(DW2102_VOLTAGE_CTRL): {
+                        u8 obuf[2];
+                        obuf[0] = 0x30;
+                        obuf[1] = msg[0].buf[0];
+                        ret = dw210x_op_rw(d->udev, 0xb2, 0, 0,
+                                        obuf, 2, DW210X_WRITE_MSG);
+                        break;
+                }
+                }
+
+                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return num;
+}
+
+static int dw2104_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int ret = 0;
+        int len, i, j;
+
+        if (!d)
+                return -ENODEV;
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (j = 0; j < num; j++) {
+                switch (msg[j].addr) {
+                case(DW2102_RC_QUERY): {
+                        u8 ibuf[2];
+                        ret  = dw210x_op_rw(d->udev, 0xb8, 0, 0,
+                                        ibuf, 2, DW210X_READ_MSG);
+                        memcpy(msg[j].buf, ibuf , 2);
+                        break;
+                }
+                case(DW2102_VOLTAGE_CTRL): {
+                        u8 obuf[2];
+                        obuf[0] = 0x30;
+                        obuf[1] = msg[j].buf[0];
+                        ret = dw210x_op_rw(d->udev, 0xb2, 0, 0,
+                                        obuf, 2, DW210X_WRITE_MSG);
+                        break;
+                }
+                /*case 0x55: cx24116
+                case 0x6a: stv0903
+                case 0x68: ds3000, stv0903
+                case 0x60: ts2020, stv6110, stb6100 */
+                default: {
+                        if (msg[j].flags == I2C_M_RD) {
+                                /* read registers */
+                                u8  ibuf[msg[j].len + 2];
+                                ret = dw210x_op_rw(d->udev, 0xc3,
+                                                (msg[j].addr << 1) + 1, 0,
+                                                ibuf, msg[j].len + 2,
+                                                DW210X_READ_MSG);
+                                memcpy(msg[j].buf, ibuf + 2, msg[j].len);
+                        mdelay(10);
+                        } else if (((msg[j].buf[0] == 0xb0) &&
+                                                (msg[j].addr == 0x68)) ||
+                                                ((msg[j].buf[0] == 0xf7) &&
+                                                (msg[j].addr == 0x55))) {
+                                /* write firmware */
+                                u8 obuf[19];
+                                obuf[0] = msg[j].addr << 1;
+                                obuf[1] = (msg[j].len > 15 ? 17 : msg[j].len);
+                                obuf[2] = msg[j].buf[0];
+                                len = msg[j].len - 1;
+                                i = 1;
+                                do {
+                                        memcpy(obuf + 3, msg[j].buf + i,
+                                                        (len > 16 ? 16 : len));
+                                        ret = dw210x_op_rw(d->udev, 0xc2, 0, 0,
+                                                obuf, (len > 16 ? 16 : len) + 3,
+                                                DW210X_WRITE_MSG);
+                                        i += 16;
+                                        len -= 16;
+                                } while (len > 0);
+                        } else {
+                                /* write registers */
+                                u8 obuf[msg[j].len + 2];
+                                obuf[0] = msg[j].addr << 1;
+                                obuf[1] = msg[j].len;
+                                memcpy(obuf + 2, msg[j].buf, msg[j].len);
+                                ret = dw210x_op_rw(d->udev, 0xc2, 0, 0,
+                                                obuf, msg[j].len + 2,
+                                                DW210X_WRITE_MSG);
+                        }
+                        break;
+                }
+                }
+
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return num;
+}
+
+static int dw3101_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                                                                int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int ret = 0, i;
+
+        if (!d)
+                return -ENODEV;
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        switch (num) {
+        case 2: {
+                /* read */
+                /* first write first register number */
+                u8 ibuf[msg[1].len + 2], obuf[3];
+                obuf[0] = msg[0].addr << 1;
+                obuf[1] = msg[0].len;
+                obuf[2] = msg[0].buf[0];
+                ret = dw210x_op_rw(d->udev, 0xc2, 0, 0,
+                                obuf, msg[0].len + 2, DW210X_WRITE_MSG);
+                /* second read registers */
+                ret = dw210x_op_rw(d->udev, 0xc3, 0x19 , 0,
+                                ibuf, msg[1].len + 2, DW210X_READ_MSG);
+                memcpy(msg[1].buf, ibuf + 2, msg[1].len);
+
+                break;
+        }
+        case 1:
+                switch (msg[0].addr) {
+                case 0x60:
+                case 0x0c: {
+                        /* write to register */
+                        u8 obuf[msg[0].len + 2];
+                        obuf[0] = msg[0].addr << 1;
+                        obuf[1] = msg[0].len;
+                        memcpy(obuf + 2, msg[0].buf, msg[0].len);
+                        ret = dw210x_op_rw(d->udev, 0xc2, 0, 0,
+                                        obuf, msg[0].len + 2, DW210X_WRITE_MSG);
+                        break;
+                }
+                case(DW2102_RC_QUERY): {
+                        u8 ibuf[2];
+                        ret  = dw210x_op_rw(d->udev, 0xb8, 0, 0,
+                                        ibuf, 2, DW210X_READ_MSG);
+                        memcpy(msg[0].buf, ibuf , 2);
+                        break;
+                }
+                }
+
+                break;
+        }
+
+        for (i = 0; i < num; i++) {
+                deb_xfer("%02x:%02x: %s ", i, msg[i].addr,
+                                msg[i].flags == 0 ? ">>>" : "<<<");
+                debug_dump(msg[i].buf, msg[i].len, deb_xfer);
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return num;
+}
+
+static int s6x0_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                                                                int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        struct usb_device *udev;
+        int ret = 0;
+        int len, i, j;
+
+        if (!d)
+                return -ENODEV;
+        udev = d->udev;
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (j = 0; j < num; j++) {
+                switch (msg[j].addr) {
+                case (DW2102_RC_QUERY): {
+                        u8 ibuf[5];
+                        ret  = dw210x_op_rw(d->udev, 0xb8, 0, 0,
+                                        ibuf, 5, DW210X_READ_MSG);
+                        memcpy(msg[j].buf, ibuf + 3, 2);
+                        break;
+                }
+                case (DW2102_VOLTAGE_CTRL): {
+                        u8 obuf[2];
+
+                        obuf[0] = 1;
+                        obuf[1] = msg[j].buf[1];/* off-on */
+                        ret = dw210x_op_rw(d->udev, 0x8a, 0, 0,
+                                        obuf, 2, DW210X_WRITE_MSG);
+                        obuf[0] = 3;
+                        obuf[1] = msg[j].buf[0];/* 13v-18v */
+                        ret = dw210x_op_rw(d->udev, 0x8a, 0, 0,
+                                        obuf, 2, DW210X_WRITE_MSG);
+                        break;
+                }
+                case (DW2102_LED_CTRL): {
+                        u8 obuf[2];
+
+                        obuf[0] = 5;
+                        obuf[1] = msg[j].buf[0];
+                        ret = dw210x_op_rw(d->udev, 0x8a, 0, 0,
+                                        obuf, 2, DW210X_WRITE_MSG);
+                        break;
+                }
+                /*case 0x55: cx24116
+                case 0x6a: stv0903
+                case 0x68: ds3000, stv0903
+                case 0x60: ts2020, stv6110, stb6100
+                case 0xa0: eeprom */
+                default: {
+                        if (msg[j].flags == I2C_M_RD) {
+                                /* read registers */
+                                u8 ibuf[msg[j].len];
+                                ret = dw210x_op_rw(d->udev, 0x91, 0, 0,
+                                                ibuf, msg[j].len,
+                                                DW210X_READ_MSG);
+                                memcpy(msg[j].buf, ibuf, msg[j].len);
+                                break;
+                        } else if ((msg[j].buf[0] == 0xb0) &&
+                                                (msg[j].addr == 0x68)) {
+                                /* write firmware */
+                                u8 obuf[19];
+                                obuf[0] = (msg[j].len > 16 ?
+                                                18 : msg[j].len + 1);
+                                obuf[1] = msg[j].addr << 1;
+                                obuf[2] = msg[j].buf[0];
+                                len = msg[j].len - 1;
+                                i = 1;
+                                do {
+                                        memcpy(obuf + 3, msg[j].buf + i,
+                                                        (len > 16 ? 16 : len));
+                                        ret = dw210x_op_rw(d->udev, 0x80, 0, 0,
+                                                obuf, (len > 16 ? 16 : len) + 3,
+                                                DW210X_WRITE_MSG);
+                                        i += 16;
+                                        len -= 16;
+                                } while (len > 0);
+                        } else if (j < (num - 1)) {
+                                /* write register addr before read */
+                                u8 obuf[msg[j].len + 2];
+                                obuf[0] = msg[j + 1].len;
+                                obuf[1] = (msg[j].addr << 1);
+                                memcpy(obuf + 2, msg[j].buf, msg[j].len);
+                                ret = dw210x_op_rw(d->udev,
+                                                udev->descriptor.idProduct ==
+                                                0x7500 ? 0x92 : 0x90, 0, 0,
+                                                obuf, msg[j].len + 2,
+                                                DW210X_WRITE_MSG);
+                                break;
+                        } else {
+                                /* write registers */
+                                u8 obuf[msg[j].len + 2];
+                                obuf[0] = msg[j].len + 1;
+                                obuf[1] = (msg[j].addr << 1);
+                                memcpy(obuf + 2, msg[j].buf, msg[j].len);
+                                ret = dw210x_op_rw(d->udev, 0x80, 0, 0,
+                                                obuf, msg[j].len + 2,
+                                                DW210X_WRITE_MSG);
+                                break;
+                        }
+                        break;
+                }
+                }
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return num;
+}
+
+static int su3000_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                                                                int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        u8 obuf[0x40], ibuf[0x40];
+
+        if (!d)
+                return -ENODEV;
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        switch (num) {
+        case 1:
+                switch (msg[0].addr) {
+                case SU3000_STREAM_CTRL:
+                        obuf[0] = msg[0].buf[0] + 0x36;
+                        obuf[1] = 3;
+                        obuf[2] = 0;
+                        if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 0, 0) < 0)
+                                err("i2c transfer failed.");
+                        break;
+                case DW2102_RC_QUERY:
+                        obuf[0] = 0x10;
+                        if (dvb_usb_generic_rw(d, obuf, 1, ibuf, 2, 0) < 0)
+                                err("i2c transfer failed.");
+                        msg[0].buf[1] = ibuf[0];
+                        msg[0].buf[0] = ibuf[1];
+                        break;
+                default:
+                        /* always i2c write*/
+                        obuf[0] = 0x08;
+                        obuf[1] = msg[0].addr;
+                        obuf[2] = msg[0].len;
+
+                        memcpy(&obuf[3], msg[0].buf, msg[0].len);
+
+                        if (dvb_usb_generic_rw(d, obuf, msg[0].len + 3,
+                                                ibuf, 1, 0) < 0)
+                                err("i2c transfer failed.");
+
+                }
+                break;
+        case 2:
+                /* always i2c read */
+                obuf[0] = 0x09;
+                obuf[1] = msg[0].len;
+                obuf[2] = msg[1].len;
+                obuf[3] = msg[0].addr;
+                memcpy(&obuf[4], msg[0].buf, msg[0].len);
+
+                if (dvb_usb_generic_rw(d, obuf, msg[0].len + 4,
+                                        ibuf, msg[1].len + 1, 0) < 0)
+                        err("i2c transfer failed.");
+
+                memcpy(msg[1].buf, &ibuf[1], msg[1].len);
+                break;
+        default:
+                warn("more than 2 i2c messages at a time is not handled yet.");
+                break;
+        }
+        mutex_unlock(&d->i2c_mutex);
+        return num;
+}
+
+static u32 dw210x_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm dw2102_i2c_algo = {
+        .master_xfer = dw2102_i2c_transfer,
+        .functionality = dw210x_i2c_func,
+};
+
+static struct i2c_algorithm dw2102_serit_i2c_algo = {
+        .master_xfer = dw2102_serit_i2c_transfer,
+        .functionality = dw210x_i2c_func,
+};
+
+static struct i2c_algorithm dw2102_earda_i2c_algo = {
+        .master_xfer = dw2102_earda_i2c_transfer,
+        .functionality = dw210x_i2c_func,
+};
+
+static struct i2c_algorithm dw2104_i2c_algo = {
+        .master_xfer = dw2104_i2c_transfer,
+        .functionality = dw210x_i2c_func,
+};
+
+static struct i2c_algorithm dw3101_i2c_algo = {
+        .master_xfer = dw3101_i2c_transfer,
+        .functionality = dw210x_i2c_func,
+};
+
+static struct i2c_algorithm s6x0_i2c_algo = {
+        .master_xfer = s6x0_i2c_transfer,
+        .functionality = dw210x_i2c_func,
+};
+
+static struct i2c_algorithm su3000_i2c_algo = {
+        .master_xfer = su3000_i2c_transfer,
+        .functionality = dw210x_i2c_func,
+};
+
+static int dw210x_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
+{
+        int i;
+        u8 ibuf[] = {0, 0};
+        u8 eeprom[256], eepromline[16];
+
+        for (i = 0; i < 256; i++) {
+                if (dw210x_op_rw(d->udev, 0xb6, 0xa0 , i, ibuf, 2, DW210X_READ_MSG) < 0) {
+                        err("read eeprom failed.");
+                        return -1;
+                } else {
+                        eepromline[i%16] = ibuf[0];
+                        eeprom[i] = ibuf[0];
+                }
+                if ((i % 16) == 15) {
+                        deb_xfer("%02x: ", i - 15);
+                        debug_dump(eepromline, 16, deb_xfer);
+                }
+        }
+
+        memcpy(mac, eeprom + 8, 6);
+        return 0;
+};
+
+static int s6x0_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
+{
+        int i, ret;
+        u8 ibuf[] = { 0 }, obuf[] = { 0 };
+        u8 eeprom[256], eepromline[16];
+        struct i2c_msg msg[] = {
+                {
+                        .addr = 0xa0 >> 1,
+                        .flags = 0,
+                        .buf = obuf,
+                        .len = 1,
+                }, {
+                        .addr = 0xa0 >> 1,
+                        .flags = I2C_M_RD,
+                        .buf = ibuf,
+                        .len = 1,
+                }
+        };
+
+        for (i = 0; i < 256; i++) {
+                obuf[0] = i;
+                ret = s6x0_i2c_transfer(&d->i2c_adap, msg, 2);
+                if (ret != 2) {
+                        err("read eeprom failed.");
+                        return -1;
+                } else {
+                        eepromline[i % 16] = ibuf[0];
+                        eeprom[i] = ibuf[0];
+                }
+
+                if ((i % 16) == 15) {
+                        deb_xfer("%02x: ", i - 15);
+                        debug_dump(eepromline, 16, deb_xfer);
+                }
+        }
+
+        memcpy(mac, eeprom + 16, 6);
+        return 0;
+};
+
+static int su3000_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        static u8 command_start[] = {0x00};
+        static u8 command_stop[] = {0x01};
+        struct i2c_msg msg = {
+                .addr = SU3000_STREAM_CTRL,
+                .flags = 0,
+                .buf = onoff ? command_start : command_stop,
+                .len = 1
+        };
+
+        i2c_transfer(&adap->dev->i2c_adap, &msg, 1);
+
+        return 0;
+}
+
+static int su3000_power_ctrl(struct dvb_usb_device *d, int i)
+{
+        struct su3000_state *state = (struct su3000_state *)d->priv;
+        u8 obuf[] = {0xde, 0};
+
+        info("%s: %d, initialized %d\n", __func__, i, state->initialized);
+
+        if (i && !state->initialized) {
+                state->initialized = 1;
+                /* reset board */
+                dvb_usb_generic_rw(d, obuf, 2, NULL, 0, 0);
+        }
+
+        return 0;
+}
+
+static int su3000_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
+{
+        int i;
+        u8 obuf[] = { 0x1f, 0xf0 };
+        u8 ibuf[] = { 0 };
+        struct i2c_msg msg[] = {
+                {
+                        .addr = 0x51,
+                        .flags = 0,
+                        .buf = obuf,
+                        .len = 2,
+                }, {
+                        .addr = 0x51,
+                        .flags = I2C_M_RD,
+                        .buf = ibuf,
+                        .len = 1,
+
+                }
+        };
+
+        for (i = 0; i < 6; i++) {
+                obuf[1] = 0xf0 + i;
+                if (i2c_transfer(&d->i2c_adap, msg, 2) != 2)
+                        break;
+                else
+                        mac[i] = ibuf[0];
+
+                debug_dump(mac, 6, printk);
+        }
+
+        return 0;
+}
+
+static int su3000_identify_state(struct usb_device *udev,
+                                 struct dvb_usb_device_properties *props,
+                                 struct dvb_usb_device_description **desc,
+                                 int *cold)
+{
+        info("%s\n", __func__);
+
+        *cold = 0;
+        return 0;
+}
+
+static int dw210x_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
+{
+        static u8 command_13v[] = {0x00, 0x01};
+        static u8 command_18v[] = {0x01, 0x01};
+        static u8 command_off[] = {0x00, 0x00};
+        struct i2c_msg msg = {
+                .addr = DW2102_VOLTAGE_CTRL,
+                .flags = 0,
+                .buf = command_off,
+                .len = 2,
+        };
+
+        struct dvb_usb_adapter *udev_adap =
+                (struct dvb_usb_adapter *)(fe->dvb->priv);
+        if (voltage == SEC_VOLTAGE_18)
+                msg.buf = command_18v;
+        else if (voltage == SEC_VOLTAGE_13)
+                msg.buf = command_13v;
+
+        i2c_transfer(&udev_adap->dev->i2c_adap, &msg, 1);
+
+        return 0;
+}
+
+static int s660_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
+{
+        struct dvb_usb_adapter *d =
+                (struct dvb_usb_adapter *)(fe->dvb->priv);
+        struct s6x0_state *st = (struct s6x0_state *)d->dev->priv;
+
+        dw210x_set_voltage(fe, voltage);
+        if (st->old_set_voltage)
+                st->old_set_voltage(fe, voltage);
+
+        return 0;
+}
+
+static void dw210x_led_ctrl(struct dvb_frontend *fe, int offon)
+{
+        static u8 led_off[] = { 0 };
+        static u8 led_on[] = { 1 };
+        struct i2c_msg msg = {
+                .addr = DW2102_LED_CTRL,
+                .flags = 0,
+                .buf = led_off,
+                .len = 1
+        };
+        struct dvb_usb_adapter *udev_adap =
+                (struct dvb_usb_adapter *)(fe->dvb->priv);
+
+        if (offon)
+                msg.buf = led_on;
+        i2c_transfer(&udev_adap->dev->i2c_adap, &msg, 1);
+}
+
+static struct stv0299_config sharp_z0194a_config = {
+        .demod_address = 0x68,
+        .inittab = sharp_z0194a_inittab,
+        .mclk = 88000000UL,
+        .invert = 1,
+        .skip_reinit = 0,
+        .lock_output = STV0299_LOCKOUTPUT_1,
+        .volt13_op0_op1 = STV0299_VOLT13_OP1,
+        .min_delay_ms = 100,
+        .set_symbol_rate = sharp_z0194a_set_symbol_rate,
+};
+
+static struct cx24116_config dw2104_config = {
+        .demod_address = 0x55,
+        .mpg_clk_pos_pol = 0x01,
+};
+
+static struct si21xx_config serit_sp1511lhb_config = {
+        .demod_address = 0x68,
+        .min_delay_ms = 100,
+
+};
+
+static struct tda10023_config dw3101_tda10023_config = {
+        .demod_address = 0x0c,
+        .invert = 1,
+};
+
+static struct mt312_config zl313_config = {
+        .demod_address = 0x0e,
+};
+
+static struct ds3000_config dw2104_ds3000_config = {
+        .demod_address = 0x68,
+};
+
+static struct stv0900_config dw2104a_stv0900_config = {
+        .demod_address = 0x6a,
+        .demod_mode = 0,
+        .xtal = 27000000,
+        .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */
+        .diseqc_mode = 2,/* 2/3 PWM */
+        .tun1_maddress = 0,/* 0x60 */
+        .tun1_adc = 0,/* 2 Vpp */
+        .path1_mode = 3,
+};
+
+static struct stb6100_config dw2104a_stb6100_config = {
+        .tuner_address = 0x60,
+        .refclock = 27000000,
+};
+
+static struct stv0900_config dw2104_stv0900_config = {
+        .demod_address = 0x68,
+        .demod_mode = 0,
+        .xtal = 8000000,
+        .clkmode = 3,
+        .diseqc_mode = 2,
+        .tun1_maddress = 0,
+        .tun1_adc = 1,/* 1 Vpp */
+        .path1_mode = 3,
+};
+
+static struct stv6110_config dw2104_stv6110_config = {
+        .i2c_address = 0x60,
+        .mclk = 16000000,
+        .clk_div = 1,
+};
+
+static struct stv0900_config prof_7500_stv0900_config = {
+        .demod_address = 0x6a,
+        .demod_mode = 0,
+        .xtal = 27000000,
+        .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */
+        .diseqc_mode = 2,/* 2/3 PWM */
+        .tun1_maddress = 0,/* 0x60 */
+        .tun1_adc = 0,/* 2 Vpp */
+        .path1_mode = 3,
+        .tun1_type = 3,
+        .set_lock_led = dw210x_led_ctrl,
+};
+
+static struct ds3000_config su3000_ds3000_config = {
+        .demod_address = 0x68,
+        .ci_mode = 1,
+};
+
+static int dw2104_frontend_attach(struct dvb_usb_adapter *d)
+{
+        struct dvb_tuner_ops *tuner_ops = NULL;
+
+        if (demod_probe & 4) {
+                d->fe = dvb_attach(stv0900_attach, &dw2104a_stv0900_config,
+                                &d->dev->i2c_adap, 0);
+                if (d->fe != NULL) {
+                        if (dvb_attach(stb6100_attach, d->fe,
+                                        &dw2104a_stb6100_config,
+                                        &d->dev->i2c_adap)) {
+                                tuner_ops = &d->fe->ops.tuner_ops;
+                                tuner_ops->set_frequency = stb6100_set_freq;
+                                tuner_ops->get_frequency = stb6100_get_freq;
+                                tuner_ops->set_bandwidth = stb6100_set_bandw;
+                                tuner_ops->get_bandwidth = stb6100_get_bandw;
+                                d->fe->ops.set_voltage = dw210x_set_voltage;
+                                info("Attached STV0900+STB6100!\n");
+                                return 0;
+                        }
+                }
+        }
+
+        if (demod_probe & 2) {
+                d->fe = dvb_attach(stv0900_attach, &dw2104_stv0900_config,
+                                &d->dev->i2c_adap, 0);
+                if (d->fe != NULL) {
+                        if (dvb_attach(stv6110_attach, d->fe,
+                                        &dw2104_stv6110_config,
+                                        &d->dev->i2c_adap)) {
+                                d->fe->ops.set_voltage = dw210x_set_voltage;
+                                info("Attached STV0900+STV6110A!\n");
+                                return 0;
+                        }
+                }
+        }
+
+        if (demod_probe & 1) {
+                d->fe = dvb_attach(cx24116_attach, &dw2104_config,
+                                &d->dev->i2c_adap);
+                if (d->fe != NULL) {
+                        d->fe->ops.set_voltage = dw210x_set_voltage;
+                        info("Attached cx24116!\n");
+                        return 0;
+                }
+        }
+
+        d->fe = dvb_attach(ds3000_attach, &dw2104_ds3000_config,
+                        &d->dev->i2c_adap);
+        if (d->fe != NULL) {
+                d->fe->ops.set_voltage = dw210x_set_voltage;
+                info("Attached DS3000!\n");
+                return 0;
+        }
+
+        return -EIO;
+}
+
+static struct dvb_usb_device_properties dw2102_properties;
+static struct dvb_usb_device_properties dw2104_properties;
+static struct dvb_usb_device_properties s6x0_properties;
+
+static int dw2102_frontend_attach(struct dvb_usb_adapter *d)
+{
+        if (dw2102_properties.i2c_algo == &dw2102_serit_i2c_algo) {
+                /*dw2102_properties.adapter->tuner_attach = NULL;*/
+                d->fe = dvb_attach(si21xx_attach, &serit_sp1511lhb_config,
+                                        &d->dev->i2c_adap);
+                if (d->fe != NULL) {
+                        d->fe->ops.set_voltage = dw210x_set_voltage;
+                        info("Attached si21xx!\n");
+                        return 0;
+                }
+        }
+
+        if (dw2102_properties.i2c_algo == &dw2102_earda_i2c_algo) {
+                d->fe = dvb_attach(stv0288_attach, &earda_config,
+                                        &d->dev->i2c_adap);
+                if (d->fe != NULL) {
+                        if (dvb_attach(stb6000_attach, d->fe, 0x61,
+                                        &d->dev->i2c_adap)) {
+                                d->fe->ops.set_voltage = dw210x_set_voltage;
+                                info("Attached stv0288!\n");
+                                return 0;
+                        }
+                }
+        }
+
+        if (dw2102_properties.i2c_algo == &dw2102_i2c_algo) {
+                /*dw2102_properties.adapter->tuner_attach = dw2102_tuner_attach;*/
+                d->fe = dvb_attach(stv0299_attach, &sharp_z0194a_config,
+                                        &d->dev->i2c_adap);
+                if (d->fe != NULL) {
+                        d->fe->ops.set_voltage = dw210x_set_voltage;
+                        info("Attached stv0299!\n");
+                        return 0;
+                }
+        }
+        return -EIO;
+}
+
+static int dw3101_frontend_attach(struct dvb_usb_adapter *d)
+{
+        d->fe = dvb_attach(tda10023_attach, &dw3101_tda10023_config,
+                                &d->dev->i2c_adap, 0x48);
+        if (d->fe != NULL) {
+                info("Attached tda10023!\n");
+                return 0;
+        }
+        return -EIO;
+}
+
+static int zl100313_frontend_attach(struct dvb_usb_adapter *d)
+{
+        d->fe = dvb_attach(mt312_attach, &zl313_config,
+                        &d->dev->i2c_adap);
+        if (d->fe != NULL) {
+                if (dvb_attach(zl10039_attach, d->fe, 0x60,
+                                &d->dev->i2c_adap)) {
+                        d->fe->ops.set_voltage = dw210x_set_voltage;
+                        info("Attached zl100313+zl10039!\n");
+                        return 0;
+                }
+        }
+
+        return -EIO;
+}
+
+static int stv0288_frontend_attach(struct dvb_usb_adapter *d)
+{
+        u8 obuf[] = {7, 1};
+
+        d->fe = dvb_attach(stv0288_attach, &earda_config,
+                        &d->dev->i2c_adap);
+
+        if (d->fe == NULL)
+                return -EIO;
+
+        if (NULL == dvb_attach(stb6000_attach, d->fe, 0x61, &d->dev->i2c_adap))
+                return -EIO;
+
+        d->fe->ops.set_voltage = dw210x_set_voltage;
+
+        dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG);
+
+        info("Attached stv0288+stb6000!\n");
+
+        return 0;
+
+}
+
+static int ds3000_frontend_attach(struct dvb_usb_adapter *d)
+{
+        struct s6x0_state *st = (struct s6x0_state *)d->dev->priv;
+        u8 obuf[] = {7, 1};
+
+        d->fe = dvb_attach(ds3000_attach, &dw2104_ds3000_config,
+                        &d->dev->i2c_adap);
+
+        if (d->fe == NULL)
+                return -EIO;
+
+        st->old_set_voltage = d->fe->ops.set_voltage;
+        d->fe->ops.set_voltage = s660_set_voltage;
+
+        dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG);
+
+        info("Attached ds3000+ds2020!\n");
+
+        return 0;
+}
+
+static int prof_7500_frontend_attach(struct dvb_usb_adapter *d)
+{
+        u8 obuf[] = {7, 1};
+
+        d->fe = dvb_attach(stv0900_attach, &prof_7500_stv0900_config,
+                                        &d->dev->i2c_adap, 0);
+        if (d->fe == NULL)
+                return -EIO;
+
+        d->fe->ops.set_voltage = dw210x_set_voltage;
+
+        dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG);
+
+        info("Attached STV0900+STB6100A!\n");
+
+        return 0;
+}
+
+static int su3000_frontend_attach(struct dvb_usb_adapter *d)
+{
+        u8 obuf[3] = { 0xe, 0x80, 0 };
+        u8 ibuf[] = { 0 };
+
+        if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
+                err("command 0x0e transfer failed.");
+
+        obuf[0] = 0xe;
+        obuf[1] = 0x83;
+        obuf[2] = 0;
+
+        if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
+                err("command 0x0e transfer failed.");
+
+        obuf[0] = 0xe;
+        obuf[1] = 0x83;
+        obuf[2] = 1;
+
+        if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
+                err("command 0x0e transfer failed.");
+
+        obuf[0] = 0x51;
+
+        if (dvb_usb_generic_rw(d->dev, obuf, 1, ibuf, 1, 0) < 0)
+                err("command 0x51 transfer failed.");
+
+        d->fe = dvb_attach(ds3000_attach, &su3000_ds3000_config,
+                                        &d->dev->i2c_adap);
+        if (d->fe == NULL)
+                return -EIO;
+
+        info("Attached DS3000!\n");
+
+        return 0;
+}
+
+static int dw2102_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(dvb_pll_attach, adap->fe, 0x60,
+                &adap->dev->i2c_adap, DVB_PLL_OPERA1);
+        return 0;
+}
+
+static int dw3101_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(dvb_pll_attach, adap->fe, 0x60,
+                &adap->dev->i2c_adap, DVB_PLL_TUA6034);
+
+        return 0;
+}
+
+static struct rc_map_table rc_map_dw210x_table[] = {
+        { 0xf80a, KEY_POWER2 },         /*power*/
+        { 0xf80c, KEY_MUTE },           /*mute*/
+        { 0xf811, KEY_1 },
+        { 0xf812, KEY_2 },
+        { 0xf813, KEY_3 },
+        { 0xf814, KEY_4 },
+        { 0xf815, KEY_5 },
+        { 0xf816, KEY_6 },
+        { 0xf817, KEY_7 },
+        { 0xf818, KEY_8 },
+        { 0xf819, KEY_9 },
+        { 0xf810, KEY_0 },
+        { 0xf81c, KEY_CHANNELUP },      /*ch+*/
+        { 0xf80f, KEY_CHANNELDOWN },    /*ch-*/
+        { 0xf81a, KEY_VOLUMEUP },       /*vol+*/
+        { 0xf80e, KEY_VOLUMEDOWN },     /*vol-*/
+        { 0xf804, KEY_RECORD },         /*rec*/
+        { 0xf809, KEY_FAVORITES },      /*fav*/
+        { 0xf808, KEY_REWIND },         /*rewind*/
+        { 0xf807, KEY_FASTFORWARD },    /*fast*/
+        { 0xf80b, KEY_PAUSE },          /*pause*/
+        { 0xf802, KEY_ESC },            /*cancel*/
+        { 0xf803, KEY_TAB },            /*tab*/
+        { 0xf800, KEY_UP },             /*up*/
+        { 0xf81f, KEY_OK },             /*ok*/
+        { 0xf801, KEY_DOWN },           /*down*/
+        { 0xf805, KEY_CAMERA },         /*cap*/
+        { 0xf806, KEY_STOP },           /*stop*/
+        { 0xf840, KEY_ZOOM },           /*full*/
+        { 0xf81e, KEY_TV },             /*tvmode*/
+        { 0xf81b, KEY_LAST },           /*recall*/
+};
+
+static struct rc_map_table rc_map_tevii_table[] = {
+        { 0xf80a, KEY_POWER },
+        { 0xf80c, KEY_MUTE },
+        { 0xf811, KEY_1 },
+        { 0xf812, KEY_2 },
+        { 0xf813, KEY_3 },
+        { 0xf814, KEY_4 },
+        { 0xf815, KEY_5 },
+        { 0xf816, KEY_6 },
+        { 0xf817, KEY_7 },
+        { 0xf818, KEY_8 },
+        { 0xf819, KEY_9 },
+        { 0xf810, KEY_0 },
+        { 0xf81c, KEY_MENU },
+        { 0xf80f, KEY_VOLUMEDOWN },
+        { 0xf81a, KEY_LAST },
+        { 0xf80e, KEY_OPEN },
+        { 0xf804, KEY_RECORD },
+        { 0xf809, KEY_VOLUMEUP },
+        { 0xf808, KEY_CHANNELUP },
+        { 0xf807, KEY_PVR },
+        { 0xf80b, KEY_TIME },
+        { 0xf802, KEY_RIGHT },
+        { 0xf803, KEY_LEFT },
+        { 0xf800, KEY_UP },
+        { 0xf81f, KEY_OK },
+        { 0xf801, KEY_DOWN },
+        { 0xf805, KEY_TUNER },
+        { 0xf806, KEY_CHANNELDOWN },
+        { 0xf840, KEY_PLAYPAUSE },
+        { 0xf81e, KEY_REWIND },
+        { 0xf81b, KEY_FAVORITES },
+        { 0xf81d, KEY_BACK },
+        { 0xf84d, KEY_FASTFORWARD },
+        { 0xf844, KEY_EPG },
+        { 0xf84c, KEY_INFO },
+        { 0xf841, KEY_AB },
+        { 0xf843, KEY_AUDIO },
+        { 0xf845, KEY_SUBTITLE },
+        { 0xf84a, KEY_LIST },
+        { 0xf846, KEY_F1 },
+        { 0xf847, KEY_F2 },
+        { 0xf85e, KEY_F3 },
+        { 0xf85c, KEY_F4 },
+        { 0xf852, KEY_F5 },
+        { 0xf85a, KEY_F6 },
+        { 0xf856, KEY_MODE },
+        { 0xf858, KEY_SWITCHVIDEOMODE },
+};
+
+static struct rc_map_table rc_map_tbs_table[] = {
+        { 0xf884, KEY_POWER },
+        { 0xf894, KEY_MUTE },
+        { 0xf887, KEY_1 },
+        { 0xf886, KEY_2 },
+        { 0xf885, KEY_3 },
+        { 0xf88b, KEY_4 },
+        { 0xf88a, KEY_5 },
+        { 0xf889, KEY_6 },
+        { 0xf88f, KEY_7 },
+        { 0xf88e, KEY_8 },
+        { 0xf88d, KEY_9 },
+        { 0xf892, KEY_0 },
+        { 0xf896, KEY_CHANNELUP },
+        { 0xf891, KEY_CHANNELDOWN },
+        { 0xf893, KEY_VOLUMEUP },
+        { 0xf88c, KEY_VOLUMEDOWN },
+        { 0xf883, KEY_RECORD },
+        { 0xf898, KEY_PAUSE  },
+        { 0xf899, KEY_OK },
+        { 0xf89a, KEY_SHUFFLE },
+        { 0xf881, KEY_UP },
+        { 0xf890, KEY_LEFT },
+        { 0xf882, KEY_RIGHT },
+        { 0xf888, KEY_DOWN },
+        { 0xf895, KEY_FAVORITES },
+        { 0xf897, KEY_SUBTITLE },
+        { 0xf89d, KEY_ZOOM },
+        { 0xf89f, KEY_EXIT },
+        { 0xf89e, KEY_MENU },
+        { 0xf89c, KEY_EPG },
+        { 0xf880, KEY_PREVIOUS },
+        { 0xf89b, KEY_MODE }
+};
+
+static struct rc_map_table rc_map_su3000_table[] = {
+        { 0x25, KEY_POWER },    /* right-bottom Red */
+        { 0x0a, KEY_MUTE },     /* -/-- */
+        { 0x01, KEY_1 },
+        { 0x02, KEY_2 },
+        { 0x03, KEY_3 },
+        { 0x04, KEY_4 },
+        { 0x05, KEY_5 },
+        { 0x06, KEY_6 },
+        { 0x07, KEY_7 },
+        { 0x08, KEY_8 },
+        { 0x09, KEY_9 },
+        { 0x00, KEY_0 },
+        { 0x20, KEY_UP },       /* CH+ */
+        { 0x21, KEY_DOWN },     /* CH+ */
+        { 0x12, KEY_VOLUMEUP }, /* Brightness Up */
+        { 0x13, KEY_VOLUMEDOWN },/* Brightness Down */
+        { 0x1f, KEY_RECORD },
+        { 0x17, KEY_PLAY },
+        { 0x16, KEY_PAUSE },
+        { 0x0b, KEY_STOP },
+        { 0x27, KEY_FASTFORWARD },/* >> */
+        { 0x26, KEY_REWIND },   /* << */
+        { 0x0d, KEY_OK },       /* Mute */
+        { 0x11, KEY_LEFT },     /* VOL- */
+        { 0x10, KEY_RIGHT },    /* VOL+ */
+        { 0x29, KEY_BACK },     /* button under 9 */
+        { 0x2c, KEY_MENU },     /* TTX */
+        { 0x2b, KEY_EPG },      /* EPG */
+        { 0x1e, KEY_RED },      /* OSD */
+        { 0x0e, KEY_GREEN },    /* Window */
+        { 0x2d, KEY_YELLOW },   /* button under << */
+        { 0x0f, KEY_BLUE },     /* bottom yellow button */
+        { 0x14, KEY_AUDIO },    /* Snapshot */
+        { 0x38, KEY_TV },       /* TV/Radio */
+        { 0x0c, KEY_ESC }       /* upper Red button */
+};
+
+static struct rc_map_dvb_usb_table_table keys_tables[] = {
+        { rc_map_dw210x_table, ARRAY_SIZE(rc_map_dw210x_table) },
+        { rc_map_tevii_table, ARRAY_SIZE(rc_map_tevii_table) },
+        { rc_map_tbs_table, ARRAY_SIZE(rc_map_tbs_table) },
+        { rc_map_su3000_table, ARRAY_SIZE(rc_map_su3000_table) },
+};
+
+static int dw2102_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
+        int keymap_size = d->props.rc.legacy.rc_map_size;
+        u8 key[2];
+        struct i2c_msg msg = {
+                .addr = DW2102_RC_QUERY,
+                .flags = I2C_M_RD,
+                .buf = key,
+                .len = 2
+        };
+        int i;
+        /* override keymap */
+        if ((ir_keymap > 0) && (ir_keymap <= ARRAY_SIZE(keys_tables))) {
+                keymap = keys_tables[ir_keymap - 1].rc_keys ;
+                keymap_size = keys_tables[ir_keymap - 1].rc_keys_size;
+        } else if (ir_keymap > ARRAY_SIZE(keys_tables))
+                return 0; /* none */
+
+        *state = REMOTE_NO_KEY_PRESSED;
+        if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) {
+                for (i = 0; i < keymap_size ; i++) {
+                        if (rc5_data(&keymap[i]) == msg.buf[0]) {
+                                *state = REMOTE_KEY_PRESSED;
+                                *event = keymap[i].keycode;
+                                break;
+                        }
+
+                }
+
+                if ((*state) == REMOTE_KEY_PRESSED)
+                        deb_rc("%s: found rc key: %x, %x, event: %x\n",
+                                        __func__, key[0], key[1], (*event));
+                else if (key[0] != 0xff)
+                        deb_rc("%s: unknown rc key: %x, %x\n",
+                                        __func__, key[0], key[1]);
+
+        }
+
+        return 0;
+}
+
+static struct usb_device_id dw2102_table[] = {
+        {USB_DEVICE(USB_VID_CYPRESS, USB_PID_DW2102)},
+        {USB_DEVICE(USB_VID_CYPRESS, 0x2101)},
+        {USB_DEVICE(USB_VID_CYPRESS, USB_PID_DW2104)},
+        {USB_DEVICE(0x9022, USB_PID_TEVII_S650)},
+        {USB_DEVICE(USB_VID_TERRATEC, USB_PID_CINERGY_S)},
+        {USB_DEVICE(USB_VID_CYPRESS, USB_PID_DW3101)},
+        {USB_DEVICE(0x9022, USB_PID_TEVII_S630)},
+        {USB_DEVICE(0x3011, USB_PID_PROF_1100)},
+        {USB_DEVICE(0x9022, USB_PID_TEVII_S660)},
+        {USB_DEVICE(0x3034, 0x7500)},
+        {USB_DEVICE(0x1f4d, 0x3000)},
+        {USB_DEVICE(USB_VID_TERRATEC, 0x00a8)},
+        {USB_DEVICE(0x9022, USB_PID_TEVII_S480_1)},
+        {USB_DEVICE(0x9022, USB_PID_TEVII_S480_2)},
+        {USB_DEVICE(0x1f4d, 0x3100)},
+        { }
+};
+
+MODULE_DEVICE_TABLE(usb, dw2102_table);
+
+static int dw2102_load_firmware(struct usb_device *dev,
+                        const struct firmware *frmwr)
+{
+        u8 *b, *p;
+        int ret = 0, i;
+        u8 reset;
+        u8 reset16[] = {0, 0, 0, 0, 0, 0, 0};
+        const struct firmware *fw;
+        const char *fw_2101 = "dvb-usb-dw2101.fw";
+
+        switch (dev->descriptor.idProduct) {
+        case 0x2101:
+                ret = request_firmware(&fw, fw_2101, &dev->dev);
+                if (ret != 0) {
+                        err(err_str, fw_2101);
+                        return ret;
+                }
+                break;
+        default:
+                fw = frmwr;
+                break;
+        }
+        info("start downloading DW210X firmware");
+        p = kmalloc(fw->size, GFP_KERNEL);
+        reset = 1;
+        /*stop the CPU*/
+        dw210x_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1, DW210X_WRITE_MSG);
+        dw210x_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1, DW210X_WRITE_MSG);
+
+        if (p != NULL) {
+                memcpy(p, fw->data, fw->size);
+                for (i = 0; i < fw->size; i += 0x40) {
+                        b = (u8 *) p + i;
+                        if (dw210x_op_rw(dev, 0xa0, i, 0, b , 0x40,
+                                        DW210X_WRITE_MSG) != 0x40) {
+                                err("error while transferring firmware");
+                                ret = -EINVAL;
+                                break;
+                        }
+                }
+                /* restart the CPU */
+                reset = 0;
+                if (ret || dw210x_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1,
+                                        DW210X_WRITE_MSG) != 1) {
+                        err("could not restart the USB controller CPU.");
+                        ret = -EINVAL;
+                }
+                if (ret || dw210x_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1,
+                                        DW210X_WRITE_MSG) != 1) {
+                        err("could not restart the USB controller CPU.");
+                        ret = -EINVAL;
+                }
+                /* init registers */
+                switch (dev->descriptor.idProduct) {
+                case USB_PID_TEVII_S650:
+                        dw2104_properties.rc.legacy.rc_map_table = rc_map_tevii_table;
+                        dw2104_properties.rc.legacy.rc_map_size =
+                                        ARRAY_SIZE(rc_map_tevii_table);
+                case USB_PID_DW2104:
+                        reset = 1;
+                        dw210x_op_rw(dev, 0xc4, 0x0000, 0, &reset, 1,
+                                        DW210X_WRITE_MSG);
+                        /* break omitted intentionally */
+                case USB_PID_DW3101:
+                        reset = 0;
+                        dw210x_op_rw(dev, 0xbf, 0x0040, 0, &reset, 0,
+                                        DW210X_WRITE_MSG);
+                        break;
+                case USB_PID_CINERGY_S:
+                case USB_PID_DW2102:
+                        dw210x_op_rw(dev, 0xbf, 0x0040, 0, &reset, 0,
+                                        DW210X_WRITE_MSG);
+                        dw210x_op_rw(dev, 0xb9, 0x0000, 0, &reset16[0], 2,
+                                        DW210X_READ_MSG);
+                        /* check STV0299 frontend  */
+                        dw210x_op_rw(dev, 0xb5, 0, 0, &reset16[0], 2,
+                                        DW210X_READ_MSG);
+                        if ((reset16[0] == 0xa1) || (reset16[0] == 0x80)) {
+                                dw2102_properties.i2c_algo = &dw2102_i2c_algo;
+                                dw2102_properties.adapter->tuner_attach = &dw2102_tuner_attach;
+                                break;
+                        } else {
+                                /* check STV0288 frontend  */
+                                reset16[0] = 0xd0;
+                                reset16[1] = 1;
+                                reset16[2] = 0;
+                                dw210x_op_rw(dev, 0xc2, 0, 0, &reset16[0], 3,
+                                                DW210X_WRITE_MSG);
+                                dw210x_op_rw(dev, 0xc3, 0xd1, 0, &reset16[0], 3,
+                                                DW210X_READ_MSG);
+                                if (reset16[2] == 0x11) {
+                                        dw2102_properties.i2c_algo = &dw2102_earda_i2c_algo;
+                                        break;
+                                }
+                        }
+                case 0x2101:
+                        dw210x_op_rw(dev, 0xbc, 0x0030, 0, &reset16[0], 2,
+                                        DW210X_READ_MSG);
+                        dw210x_op_rw(dev, 0xba, 0x0000, 0, &reset16[0], 7,
+                                        DW210X_READ_MSG);
+                        dw210x_op_rw(dev, 0xba, 0x0000, 0, &reset16[0], 7,
+                                        DW210X_READ_MSG);
+                        dw210x_op_rw(dev, 0xb9, 0x0000, 0, &reset16[0], 2,
+                                        DW210X_READ_MSG);
+                        break;
+                }
+
+                msleep(100);
+                kfree(p);
+        }
+        return ret;
+}
+
+static struct dvb_usb_device_properties dw2102_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "dvb-usb-dw2102.fw",
+        .no_reconnect = 1,
+
+        .i2c_algo = &dw2102_serit_i2c_algo,
+
+        .rc.legacy = {
+                .rc_map_table = rc_map_dw210x_table,
+                .rc_map_size = ARRAY_SIZE(rc_map_dw210x_table),
+                .rc_interval = 150,
+                .rc_query = dw2102_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x81,
+        /* parameter for the MPEG2-data transfer */
+        .num_adapters = 1,
+        .download_firmware = dw2102_load_firmware,
+        .read_mac_address = dw210x_read_mac_address,
+        .adapter = {
+                {
+                        .frontend_attach = dw2102_frontend_attach,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 8,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+        .num_device_descs = 3,
+        .devices = {
+                {"DVBWorld DVB-S 2102 USB2.0",
+                        {&dw2102_table[0], NULL},
+                        {NULL},
+                },
+                {"DVBWorld DVB-S 2101 USB2.0",
+                        {&dw2102_table[1], NULL},
+                        {NULL},
+                },
+                {"TerraTec Cinergy S USB",
+                        {&dw2102_table[4], NULL},
+                        {NULL},
+                },
+        }
+};
+
+static struct dvb_usb_device_properties dw2104_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "dvb-usb-dw2104.fw",
+        .no_reconnect = 1,
+
+        .i2c_algo = &dw2104_i2c_algo,
+        .rc.legacy = {
+                .rc_map_table = rc_map_dw210x_table,
+                .rc_map_size = ARRAY_SIZE(rc_map_dw210x_table),
+                .rc_interval = 150,
+                .rc_query = dw2102_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x81,
+        /* parameter for the MPEG2-data transfer */
+        .num_adapters = 1,
+        .download_firmware = dw2102_load_firmware,
+        .read_mac_address = dw210x_read_mac_address,
+        .adapter = {
+                {
+                        .frontend_attach = dw2104_frontend_attach,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 8,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+        .num_device_descs = 2,
+        .devices = {
+                { "DVBWorld DW2104 USB2.0",
+                        {&dw2102_table[2], NULL},
+                        {NULL},
+                },
+                { "TeVii S650 USB2.0",
+                        {&dw2102_table[3], NULL},
+                        {NULL},
+                },
+        }
+};
+
+static struct dvb_usb_device_properties dw3101_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "dvb-usb-dw3101.fw",
+        .no_reconnect = 1,
+
+        .i2c_algo = &dw3101_i2c_algo,
+        .rc.legacy = {
+                .rc_map_table = rc_map_dw210x_table,
+                .rc_map_size = ARRAY_SIZE(rc_map_dw210x_table),
+                .rc_interval = 150,
+                .rc_query = dw2102_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x81,
+        /* parameter for the MPEG2-data transfer */
+        .num_adapters = 1,
+        .download_firmware = dw2102_load_firmware,
+        .read_mac_address = dw210x_read_mac_address,
+        .adapter = {
+                {
+                        .frontend_attach = dw3101_frontend_attach,
+                        .tuner_attach = dw3101_tuner_attach,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 8,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+        .num_device_descs = 1,
+        .devices = {
+                { "DVBWorld DVB-C 3101 USB2.0",
+                        {&dw2102_table[5], NULL},
+                        {NULL},
+                },
+        }
+};
+
+static struct dvb_usb_device_properties s6x0_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .size_of_priv = sizeof(struct s6x0_state),
+        .firmware = "dvb-usb-s630.fw",
+        .no_reconnect = 1,
+
+        .i2c_algo = &s6x0_i2c_algo,
+        .rc.legacy = {
+                .rc_map_table = rc_map_tevii_table,
+                .rc_map_size = ARRAY_SIZE(rc_map_tevii_table),
+                .rc_interval = 150,
+                .rc_query = dw2102_rc_query,
+        },
+
+        .generic_bulk_ctrl_endpoint = 0x81,
+        .num_adapters = 1,
+        .download_firmware = dw2102_load_firmware,
+        .read_mac_address = s6x0_read_mac_address,
+        .adapter = {
+                {
+                        .frontend_attach = zl100313_frontend_attach,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 8,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+        .num_device_descs = 1,
+        .devices = {
+                {"TeVii S630 USB",
+                        {&dw2102_table[6], NULL},
+                        {NULL},
+                },
+        }
+};
+
+struct dvb_usb_device_properties *p1100;
+static struct dvb_usb_device_description d1100 = {
+        "Prof 1100 USB ",
+        {&dw2102_table[7], NULL},
+        {NULL},
+};
+
+struct dvb_usb_device_properties *s660;
+static struct dvb_usb_device_description d660 = {
+        "TeVii S660 USB",
+        {&dw2102_table[8], NULL},
+        {NULL},
+};
+
+static struct dvb_usb_device_description d480_1 = {
+        "TeVii S480.1 USB",
+        {&dw2102_table[12], NULL},
+        {NULL},
+};
+
+static struct dvb_usb_device_description d480_2 = {
+        "TeVii S480.2 USB",
+        {&dw2102_table[13], NULL},
+        {NULL},
+};
+
+struct dvb_usb_device_properties *p7500;
+static struct dvb_usb_device_description d7500 = {
+        "Prof 7500 USB DVB-S2",
+        {&dw2102_table[9], NULL},
+        {NULL},
+};
+
+static struct dvb_usb_device_properties su3000_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .size_of_priv = sizeof(struct su3000_state),
+        .power_ctrl = su3000_power_ctrl,
+        .num_adapters = 1,
+        .identify_state = su3000_identify_state,
+        .i2c_algo = &su3000_i2c_algo,
+
+        .rc.legacy = {
+                .rc_map_table = rc_map_su3000_table,
+                .rc_map_size = ARRAY_SIZE(rc_map_su3000_table),
+                .rc_interval = 150,
+                .rc_query = dw2102_rc_query,
+        },
+
+        .read_mac_address = su3000_read_mac_address,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .adapter = {
+                {
+                        .streaming_ctrl   = su3000_streaming_ctrl,
+                        .frontend_attach  = su3000_frontend_attach,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 8,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        }
+                }
+        },
+        .num_device_descs = 3,
+        .devices = {
+                { "SU3000HD DVB-S USB2.0",
+                        { &dw2102_table[10], NULL },
+                        { NULL },
+                },
+                { "Terratec Cinergy S2 USB HD",
+                        { &dw2102_table[11], NULL },
+                        { NULL },
+                },
+                { "X3M TV SPC1400HD PCI",
+                        { &dw2102_table[14], NULL },
+                        { NULL },
+                },
+        }
+};
+
+static int dw2102_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        p1100 = kzalloc(sizeof(struct dvb_usb_device_properties), GFP_KERNEL);
+        if (!p1100)
+                return -ENOMEM;
+        /* copy default structure */
+        memcpy(p1100, &s6x0_properties,
+                        sizeof(struct dvb_usb_device_properties));
+        /* fill only different fields */
+        p1100->firmware = "dvb-usb-p1100.fw";
+        p1100->devices[0] = d1100;
+        p1100->rc.legacy.rc_map_table = rc_map_tbs_table;
+        p1100->rc.legacy.rc_map_size = ARRAY_SIZE(rc_map_tbs_table);
+        p1100->adapter->frontend_attach = stv0288_frontend_attach;
+
+        s660 = kzalloc(sizeof(struct dvb_usb_device_properties), GFP_KERNEL);
+        if (!s660) {
+                kfree(p1100);
+                return -ENOMEM;
+        }
+        memcpy(s660, &s6x0_properties,
+                        sizeof(struct dvb_usb_device_properties));
+        s660->firmware = "dvb-usb-s660.fw";
+        s660->num_device_descs = 3;
+        s660->devices[0] = d660;
+        s660->devices[1] = d480_1;
+        s660->devices[2] = d480_2;
+        s660->adapter->frontend_attach = ds3000_frontend_attach;
+
+        p7500 = kzalloc(sizeof(struct dvb_usb_device_properties), GFP_KERNEL);
+        if (!p7500) {
+                kfree(p1100);
+                kfree(s660);
+                return -ENOMEM;
+        }
+        memcpy(p7500, &s6x0_properties,
+                        sizeof(struct dvb_usb_device_properties));
+        p7500->firmware = "dvb-usb-p7500.fw";
+        p7500->devices[0] = d7500;
+        p7500->rc.legacy.rc_map_table = rc_map_tbs_table;
+        p7500->rc.legacy.rc_map_size = ARRAY_SIZE(rc_map_tbs_table);
+        p7500->adapter->frontend_attach = prof_7500_frontend_attach;
+
+        if (0 == dvb_usb_device_init(intf, &dw2102_properties,
+                        THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &dw2104_properties,
+                        THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &dw3101_properties,
+                        THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &s6x0_properties,
+                        THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, p1100,
+                        THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, s660,
+                        THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, p7500,
+                        THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &su3000_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
+                return 0;
+
+        return -ENODEV;
+}
+
+static struct usb_driver dw2102_driver = {
+        .name = "dw2102",
+        .probe = dw2102_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table = dw2102_table,
+};
+
+static int __init dw2102_module_init(void)
+{
+        int ret =  usb_register(&dw2102_driver);
+        if (ret)
+                err("usb_register failed. Error number %d", ret);
+
+        return ret;
+}
+
+static void __exit dw2102_module_exit(void)
+{
+        usb_deregister(&dw2102_driver);
+}
+
+module_init(dw2102_module_init);
+module_exit(dw2102_module_exit);
+
+MODULE_AUTHOR("Igor M. Liplianin (c) liplianin@me.by");
+MODULE_DESCRIPTION("Driver for DVBWorld DVB-S 2101, 2102, DVB-S2 2104,"
+                                " DVB-C 3101 USB2.0,"
+                                " TeVii S600, S630, S650, S660, S480,"
+                                " Prof 1100, 7500 USB2.0,"
+                                " Geniatech SU3000 devices");
+MODULE_VERSION("0.1");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/dw2102.h b/drivers/media/dvb/dvb-usb/dw2102.h
new file mode 100644
index 00000000000..5cd0b0eb6ce
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/dw2102.h
@@ -0,0 +1,9 @@
+#ifndef _DW2102_H_
+#define _DW2102_H_
+
+#define DVB_USB_LOG_PREFIX "dw2102"
+#include "dvb-usb.h"
+
+#define deb_xfer(args...) dprintk(dvb_usb_dw2102_debug, 0x02, args)
+#define deb_rc(args...)   dprintk(dvb_usb_dw2102_debug, 0x04, args)
+#endif
diff --git a/drivers/media/dvb/dvb-usb/ec168.c b/drivers/media/dvb/dvb-usb/ec168.c
new file mode 100644
index 00000000000..1ba3e5dbee1
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/ec168.c
@@ -0,0 +1,452 @@
+/*
+ * E3C EC168 DVB USB driver
+ *
+ * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
+ *
+ *    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 "ec168.h"
+#include "ec100.h"
+#include "mxl5005s.h"
+
+/* debug */
+static int dvb_usb_ec168_debug;
+module_param_named(debug, dvb_usb_ec168_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static struct ec100_config ec168_ec100_config;
+
+static int ec168_rw_udev(struct usb_device *udev, struct ec168_req *req)
+{
+        int ret;
+        unsigned int pipe;
+        u8 request, requesttype;
+        u8 *buf;
+
+
+
+        switch (req->cmd) {
+        case DOWNLOAD_FIRMWARE:
+        case GPIO:
+        case WRITE_I2C:
+        case STREAMING_CTRL:
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
+                request = req->cmd;
+                break;
+        case READ_I2C:
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
+                request = req->cmd;
+                break;
+        case GET_CONFIG:
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
+                request = CONFIG;
+                break;
+        case SET_CONFIG:
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
+                request = CONFIG;
+                break;
+        case WRITE_DEMOD:
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
+                request = DEMOD_RW;
+                break;
+        case READ_DEMOD:
+                requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
+                request = DEMOD_RW;
+                break;
+        default:
+                err("unknown command:%02x", req->cmd);
+                ret = -EPERM;
+                goto error;
+        }
+
+        buf = kmalloc(req->size, GFP_KERNEL);
+        if (!buf) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        if (requesttype == (USB_TYPE_VENDOR | USB_DIR_OUT)) {
+                /* write */
+                memcpy(buf, req->data, req->size);
+                pipe = usb_sndctrlpipe(udev, 0);
+        } else {
+                /* read */
+                pipe = usb_rcvctrlpipe(udev, 0);
+        }
+
+        msleep(1); /* avoid I2C errors */
+
+        ret = usb_control_msg(udev, pipe, request, requesttype, req->value,
+                req->index, buf, req->size, EC168_USB_TIMEOUT);
+
+        ec168_debug_dump(request, requesttype, req->value, req->index, buf,
+                req->size, deb_xfer);
+
+        if (ret < 0)
+                goto err_dealloc;
+        else
+                ret = 0;
+
+        /* read request, copy returned data to return buf */
+        if (!ret && requesttype == (USB_TYPE_VENDOR | USB_DIR_IN))
+                memcpy(req->data, buf, req->size);
+
+        kfree(buf);
+        return ret;
+
+err_dealloc:
+        kfree(buf);
+error:
+        deb_info("%s: failed:%d\n", __func__, ret);
+        return ret;
+}
+
+static int ec168_ctrl_msg(struct dvb_usb_device *d, struct ec168_req *req)
+{
+        return ec168_rw_udev(d->udev, req);
+}
+
+/* I2C */
+static int ec168_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+        int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        struct ec168_req req;
+        int i = 0;
+        int ret;
+
+        if (num > 2)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        while (i < num) {
+                if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
+                        if (msg[i].addr == ec168_ec100_config.demod_address) {
+                                req.cmd = READ_DEMOD;
+                                req.value = 0;
+                                req.index = 0xff00 + msg[i].buf[0]; /* reg */
+                                req.size = msg[i+1].len; /* bytes to read */
+                                req.data = &msg[i+1].buf[0];
+                                ret = ec168_ctrl_msg(d, &req);
+                                i += 2;
+                        } else {
+                                err("I2C read not implemented");
+                                ret = -ENOSYS;
+                                i += 2;
+                        }
+                } else {
+                        if (msg[i].addr == ec168_ec100_config.demod_address) {
+                                req.cmd = WRITE_DEMOD;
+                                req.value = msg[i].buf[1]; /* val */
+                                req.index = 0xff00 + msg[i].buf[0]; /* reg */
+                                req.size = 0;
+                                req.data = NULL;
+                                ret = ec168_ctrl_msg(d, &req);
+                                i += 1;
+                        } else {
+                                req.cmd = WRITE_I2C;
+                                req.value = msg[i].buf[0]; /* val */
+                                req.index = 0x0100 + msg[i].addr; /* I2C addr */
+                                req.size = msg[i].len-1;
+                                req.data = &msg[i].buf[1];
+                                ret = ec168_ctrl_msg(d, &req);
+                                i += 1;
+                        }
+                }
+                if (ret)
+                        goto error;
+
+        }
+        ret = i;
+
+error:
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+
+static u32 ec168_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm ec168_i2c_algo = {
+        .master_xfer   = ec168_i2c_xfer,
+        .functionality = ec168_i2c_func,
+};
+
+/* Callbacks for DVB USB */
+static struct ec100_config ec168_ec100_config = {
+        .demod_address = 0xff, /* not real address, demod is integrated */
+};
+
+static int ec168_ec100_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        deb_info("%s:\n", __func__);
+        adap->fe = dvb_attach(ec100_attach, &ec168_ec100_config,
+                &adap->dev->i2c_adap);
+        if (adap->fe == NULL)
+                return -ENODEV;
+
+        return 0;
+}
+
+static struct mxl5005s_config ec168_mxl5003s_config = {
+        .i2c_address     = 0xc6,
+        .if_freq         = IF_FREQ_4570000HZ,
+        .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
+        .agc_mode        = MXL_SINGLE_AGC,
+        .tracking_filter = MXL_TF_OFF,
+        .rssi_enable     = MXL_RSSI_ENABLE,
+        .cap_select      = MXL_CAP_SEL_ENABLE,
+        .div_out         = MXL_DIV_OUT_4,
+        .clock_out       = MXL_CLOCK_OUT_DISABLE,
+        .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
+        .top             = MXL5005S_TOP_25P2,
+        .mod_mode        = MXL_DIGITAL_MODE,
+        .if_mode         = MXL_ZERO_IF,
+        .AgcMasterByte   = 0x00,
+};
+
+static int ec168_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        deb_info("%s:\n", __func__);
+        return dvb_attach(mxl5005s_attach, adap->fe, &adap->dev->i2c_adap,
+                &ec168_mxl5003s_config) == NULL ? -ENODEV : 0;
+}
+
+static int ec168_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        struct ec168_req req = {STREAMING_CTRL, 0x7f01, 0x0202, 0, NULL};
+        deb_info("%s: onoff:%d\n", __func__, onoff);
+        if (onoff)
+                req.index = 0x0102;
+        return ec168_ctrl_msg(adap->dev, &req);
+}
+
+static int ec168_download_firmware(struct usb_device *udev,
+        const struct firmware *fw)
+{
+        int i, len, packets, remainder, ret;
+        u16 addr = 0x0000; /* firmware start address */
+        struct ec168_req req = {DOWNLOAD_FIRMWARE, 0, 0, 0, NULL};
+        deb_info("%s:\n", __func__);
+
+        #define FW_PACKET_MAX_DATA  2048
+        packets = fw->size / FW_PACKET_MAX_DATA;
+        remainder = fw->size % FW_PACKET_MAX_DATA;
+        len = FW_PACKET_MAX_DATA;
+        for (i = 0; i <= packets; i++) {
+                if (i == packets)  /* set size of the last packet */
+                        len = remainder;
+
+                req.size = len;
+                req.data = (u8 *)(fw->data + i * FW_PACKET_MAX_DATA);
+                req.index = addr;
+                addr += FW_PACKET_MAX_DATA;
+
+                ret = ec168_rw_udev(udev, &req);
+                if (ret) {
+                        err("firmware download failed:%d packet:%d", ret, i);
+                        goto error;
+                }
+        }
+        req.size = 0;
+
+        /* set "warm"? */
+        req.cmd = SET_CONFIG;
+        req.value = 0;
+        req.index = 0x0001;
+        ret = ec168_rw_udev(udev, &req);
+        if (ret)
+                goto error;
+
+        /* really needed - no idea what does */
+        req.cmd = GPIO;
+        req.value = 0;
+        req.index = 0x0206;
+        ret = ec168_rw_udev(udev, &req);
+        if (ret)
+                goto error;
+
+        /* activate tuner I2C? */
+        req.cmd = WRITE_I2C;
+        req.value = 0;
+        req.index = 0x00c6;
+        ret = ec168_rw_udev(udev, &req);
+        if (ret)
+                goto error;
+
+        return ret;
+error:
+        deb_info("%s: failed:%d\n", __func__, ret);
+        return ret;
+}
+
+static int ec168_identify_state(struct usb_device *udev,
+        struct dvb_usb_device_properties *props,
+        struct dvb_usb_device_description **desc, int *cold)
+{
+        int ret;
+        u8 reply;
+        struct ec168_req req = {GET_CONFIG, 0, 1, sizeof(reply), &reply};
+        deb_info("%s:\n", __func__);
+
+        ret = ec168_rw_udev(udev, &req);
+        if (ret)
+                goto error;
+
+        deb_info("%s: reply:%02x\n", __func__, reply);
+
+        if (reply == 0x01)
+                *cold = 0;
+        else
+                *cold = 1;
+
+        return ret;
+error:
+        deb_info("%s: failed:%d\n", __func__, ret);
+        return ret;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties ec168_properties;
+
+static int ec168_probe(struct usb_interface *intf,
+        const struct usb_device_id *id)
+{
+        int ret;
+        deb_info("%s: interface:%d\n", __func__,
+                intf->cur_altsetting->desc.bInterfaceNumber);
+
+        ret = dvb_usb_device_init(intf, &ec168_properties, THIS_MODULE, NULL,
+                adapter_nr);
+        if (ret)
+                goto error;
+
+        return ret;
+error:
+        deb_info("%s: failed:%d\n", __func__, ret);
+        return ret;
+}
+
+#define E3C_EC168_1689                          0
+#define E3C_EC168_FFFA                          1
+#define E3C_EC168_FFFB                          2
+#define E3C_EC168_1001                          3
+#define E3C_EC168_1002                          4
+
+static struct usb_device_id ec168_id[] = {
+        [E3C_EC168_1689] =
+                {USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168)},
+        [E3C_EC168_FFFA] =
+                {USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168_2)},
+        [E3C_EC168_FFFB] =
+                {USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168_3)},
+        [E3C_EC168_1001] =
+                {USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168_4)},
+        [E3C_EC168_1002] =
+                {USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168_5)},
+        {} /* terminating entry */
+};
+
+MODULE_DEVICE_TABLE(usb, ec168_id);
+
+static struct dvb_usb_device_properties ec168_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .download_firmware = ec168_download_firmware,
+        .firmware = "dvb-usb-ec168.fw",
+        .no_reconnect = 1,
+
+        .size_of_priv = 0,
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = ec168_streaming_ctrl,
+                        .frontend_attach  = ec168_ec100_frontend_attach,
+                        .tuner_attach     = ec168_mxl5003s_tuner_attach,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 6,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = (32*512),
+                                        }
+                                }
+                        },
+                }
+        },
+
+        .identify_state = ec168_identify_state,
+
+        .i2c_algo = &ec168_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        .name = "E3C EC168 DVB-T USB2.0 reference design",
+                        .cold_ids = {
+                                &ec168_id[E3C_EC168_1689],
+                                &ec168_id[E3C_EC168_FFFA],
+                                &ec168_id[E3C_EC168_FFFB],
+                                &ec168_id[E3C_EC168_1001],
+                                &ec168_id[E3C_EC168_1002],
+                                NULL},
+                        .warm_ids = {NULL},
+                },
+        }
+};
+
+static struct usb_driver ec168_driver = {
+        .name       = "dvb_usb_ec168",
+        .probe      = ec168_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table   = ec168_id,
+};
+
+/* module stuff */
+static int __init ec168_module_init(void)
+{
+        int ret;
+        deb_info("%s:\n", __func__);
+        ret = usb_register(&ec168_driver);
+        if (ret)
+                err("module init failed:%d", ret);
+
+        return ret;
+}
+
+static void __exit ec168_module_exit(void)
+{
+        deb_info("%s:\n", __func__);
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&ec168_driver);
+}
+
+module_init(ec168_module_init);
+module_exit(ec168_module_exit);
+
+MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+MODULE_DESCRIPTION("E3C EC168 DVB-T USB2.0 driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/ec168.h b/drivers/media/dvb/dvb-usb/ec168.h
new file mode 100644
index 00000000000..e7e0b831314
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/ec168.h
@@ -0,0 +1,73 @@
+/*
+ * E3C EC168 DVB USB driver
+ *
+ * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
+ *
+ *    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 EC168_H
+#define EC168_H
+
+#define DVB_USB_LOG_PREFIX "ec168"
+#include "dvb-usb.h"
+
+#define deb_info(args...) dprintk(dvb_usb_ec168_debug, 0x01, args)
+#define deb_rc(args...)   dprintk(dvb_usb_ec168_debug, 0x02, args)
+#define deb_xfer(args...) dprintk(dvb_usb_ec168_debug, 0x04, args)
+#define deb_reg(args...)  dprintk(dvb_usb_ec168_debug, 0x08, args)
+#define deb_i2c(args...)  dprintk(dvb_usb_ec168_debug, 0x10, args)
+#define deb_fw(args...)   dprintk(dvb_usb_ec168_debug, 0x20, args)
+
+#define ec168_debug_dump(r, t, v, i, b, l, func) { \
+        int loop_; \
+        func("%02x %02x %02x %02x %02x %02x %02x %02x", \
+                t, r, v & 0xff, v >> 8, i & 0xff, i >> 8, l & 0xff, l >> 8); \
+        if (t == (USB_TYPE_VENDOR | USB_DIR_OUT)) \
+                func(" >>> "); \
+        else \
+                func(" <<< "); \
+        for (loop_ = 0; loop_ < l; loop_++) \
+                func("%02x ", b[loop_]); \
+        func("\n");\
+}
+
+#define EC168_USB_TIMEOUT 1000
+
+struct ec168_req {
+        u8  cmd;       /* [1] */
+        u16 value;     /* [2|3] */
+        u16 index;     /* [4|5] */
+        u16 size;      /* [6|7] */
+        u8  *data;
+};
+
+enum ec168_cmd {
+        DOWNLOAD_FIRMWARE    = 0x00,
+        CONFIG               = 0x01,
+        DEMOD_RW             = 0x03,
+        GPIO                 = 0x04,
+        STREAMING_CTRL       = 0x10,
+        READ_I2C             = 0x20,
+        WRITE_I2C            = 0x21,
+        HID_DOWNLOAD         = 0x30,
+        GET_CONFIG,
+        SET_CONFIG,
+        READ_DEMOD,
+        WRITE_DEMOD,
+};
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/friio-fe.c b/drivers/media/dvb/dvb-usb/friio-fe.c
new file mode 100644
index 00000000000..015b4e8af1a
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/friio-fe.c
@@ -0,0 +1,474 @@
+/* DVB USB compliant Linux driver for the Friio USB2.0 ISDB-T receiver.
+ *
+ * Copyright (C) 2009 Akihiro Tsukada <tskd2@yahoo.co.jp>
+ *
+ * This module is based off the the gl861 and vp702x modules.
+ *
+ * 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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+
+#include "friio.h"
+
+struct jdvbt90502_state {
+        struct i2c_adapter *i2c;
+        struct dvb_frontend frontend;
+        struct jdvbt90502_config config;
+};
+
+/* NOTE: TC90502 has 16bit register-address? */
+/* register 0x0100 is used for reading PLL status, so reg is u16 here */
+static int jdvbt90502_reg_read(struct jdvbt90502_state *state,
+                               const u16 reg, u8 *buf, const size_t count)
+{
+        int ret;
+        u8 wbuf[3];
+        struct i2c_msg msg[2];
+
+        wbuf[0] = reg & 0xFF;
+        wbuf[1] = 0;
+        wbuf[2] = reg >> 8;
+
+        msg[0].addr = state->config.demod_address;
+        msg[0].flags = 0;
+        msg[0].buf = wbuf;
+        msg[0].len = sizeof(wbuf);
+
+        msg[1].addr = msg[0].addr;
+        msg[1].flags = I2C_M_RD;
+        msg[1].buf = buf;
+        msg[1].len = count;
+
+        ret = i2c_transfer(state->i2c, msg, 2);
+        if (ret != 2) {
+                deb_fe(" reg read failed.\n");
+                return -EREMOTEIO;
+        }
+        return 0;
+}
+
+/* currently 16bit register-address is not used, so reg is u8 here */
+static int jdvbt90502_single_reg_write(struct jdvbt90502_state *state,
+                                       const u8 reg, const u8 val)
+{
+        struct i2c_msg msg;
+        u8 wbuf[2];
+
+        wbuf[0] = reg;
+        wbuf[1] = val;
+
+        msg.addr = state->config.demod_address;
+        msg.flags = 0;
+        msg.buf = wbuf;
+        msg.len = sizeof(wbuf);
+
+        if (i2c_transfer(state->i2c, &msg, 1) != 1) {
+                deb_fe(" reg write failed.");
+                return -EREMOTEIO;
+        }
+        return 0;
+}
+
+static int _jdvbt90502_write(struct dvb_frontend *fe, const u8 buf[], int len)
+{
+        struct jdvbt90502_state *state = fe->demodulator_priv;
+        int err, i;
+        for (i = 0; i < len - 1; i++) {
+                err = jdvbt90502_single_reg_write(state,
+                                                  buf[0] + i, buf[i + 1]);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+/* read pll status byte via the demodulator's I2C register */
+/* note: Win box reads it by 8B block at the I2C addr 0x30 from reg:0x80 */
+static int jdvbt90502_pll_read(struct jdvbt90502_state *state, u8 *result)
+{
+        int ret;
+
+        /* +1 for reading */
+        u8 pll_addr_byte = (state->config.pll_address << 1) + 1;
+
+        *result = 0;
+
+        ret = jdvbt90502_single_reg_write(state, JDVBT90502_2ND_I2C_REG,
+                                          pll_addr_byte);
+        if (ret)
+                goto error;
+
+        ret = jdvbt90502_reg_read(state, 0x0100, result, 1);
+        if (ret)
+                goto error;
+
+        deb_fe("PLL read val:%02x\n", *result);
+        return 0;
+
+error:
+        deb_fe("%s:ret == %d\n", __func__, ret);
+        return -EREMOTEIO;
+}
+
+
+/* set pll frequency via the demodulator's I2C register */
+static int jdvbt90502_pll_set_freq(struct jdvbt90502_state *state, u32 freq)
+{
+        int ret;
+        int retry;
+        u8 res1;
+        u8 res2[9];
+
+        u8 pll_freq_cmd[PLL_CMD_LEN];
+        u8 pll_agc_cmd[PLL_CMD_LEN];
+        struct i2c_msg msg[2];
+        u32 f;
+
+        deb_fe("%s: freq=%d, step=%d\n", __func__, freq,
+               state->frontend.ops.info.frequency_stepsize);
+        /* freq -> oscilator frequency conversion. */
+        /* freq: 473,000,000 + n*6,000,000 [+ 142857 (center freq. shift)] */
+        f = freq / state->frontend.ops.info.frequency_stepsize;
+        /* add 399[1/7 MHZ] = 57MHz for the IF  */
+        f += 399;
+        /* add center frequency shift if necessary */
+        if (f % 7 == 0)
+                f++;
+        pll_freq_cmd[DEMOD_REDIRECT_REG] = JDVBT90502_2ND_I2C_REG; /* 0xFE */
+        pll_freq_cmd[ADDRESS_BYTE] = state->config.pll_address << 1;
+        pll_freq_cmd[DIVIDER_BYTE1] = (f >> 8) & 0x7F;
+        pll_freq_cmd[DIVIDER_BYTE2] = f & 0xFF;
+        pll_freq_cmd[CONTROL_BYTE] = 0xB2; /* ref.divider:28, 4MHz/28=1/7MHz */
+        pll_freq_cmd[BANDSWITCH_BYTE] = 0x08;   /* UHF band */
+
+        msg[0].addr = state->config.demod_address;
+        msg[0].flags = 0;
+        msg[0].buf = pll_freq_cmd;
+        msg[0].len = sizeof(pll_freq_cmd);
+
+        ret = i2c_transfer(state->i2c, &msg[0], 1);
+        if (ret != 1)
+                goto error;
+
+        udelay(50);
+
+        pll_agc_cmd[DEMOD_REDIRECT_REG] = pll_freq_cmd[DEMOD_REDIRECT_REG];
+        pll_agc_cmd[ADDRESS_BYTE] = pll_freq_cmd[ADDRESS_BYTE];
+        pll_agc_cmd[DIVIDER_BYTE1] = pll_freq_cmd[DIVIDER_BYTE1];
+        pll_agc_cmd[DIVIDER_BYTE2] = pll_freq_cmd[DIVIDER_BYTE2];
+        pll_agc_cmd[CONTROL_BYTE] = 0x9A; /*  AGC_CTRL instead of BANDSWITCH */
+        pll_agc_cmd[AGC_CTRL_BYTE] = 0x50;
+        /* AGC Time Constant 2s, AGC take-over point:103dBuV(lowest) */
+
+        msg[1].addr = msg[0].addr;
+        msg[1].flags = 0;
+        msg[1].buf = pll_agc_cmd;
+        msg[1].len = sizeof(pll_agc_cmd);
+
+        ret = i2c_transfer(state->i2c, &msg[1], 1);
+        if (ret != 1)
+                goto error;
+
+        /* I don't know what these cmds are for,  */
+        /* but the USB log on a windows box contains them */
+        ret = jdvbt90502_single_reg_write(state, 0x01, 0x40);
+        ret |= jdvbt90502_single_reg_write(state, 0x01, 0x00);
+        if (ret)
+                goto error;
+        udelay(100);
+
+        /* wait for the demod to be ready? */
+#define RETRY_COUNT 5
+        for (retry = 0; retry < RETRY_COUNT; retry++) {
+                ret = jdvbt90502_reg_read(state, 0x0096, &res1, 1);
+                if (ret)
+                        goto error;
+                /* if (res1 != 0x00) goto error; */
+                ret = jdvbt90502_reg_read(state, 0x00B0, res2, sizeof(res2));
+                if (ret)
+                        goto error;
+                if (res2[0] >= 0xA7)
+                        break;
+                msleep(100);
+        }
+        if (retry >= RETRY_COUNT) {
+                deb_fe("%s: FE does not get ready after freq setting.\n",
+                       __func__);
+                return -EREMOTEIO;
+        }
+
+        return 0;
+error:
+        deb_fe("%s:ret == %d\n", __func__, ret);
+        return -EREMOTEIO;
+}
+
+static int jdvbt90502_read_status(struct dvb_frontend *fe, fe_status_t *state)
+{
+        u8 result;
+        int ret;
+
+        *state = FE_HAS_SIGNAL;
+
+        ret = jdvbt90502_pll_read(fe->demodulator_priv, &result);
+        if (ret) {
+                deb_fe("%s:ret == %d\n", __func__, ret);
+                return -EREMOTEIO;
+        }
+
+        *state = FE_HAS_SIGNAL
+                | FE_HAS_CARRIER
+                | FE_HAS_VITERBI
+                | FE_HAS_SYNC;
+
+        if (result & PLL_STATUS_LOCKED)
+                *state |= FE_HAS_LOCK;
+
+        return 0;
+}
+
+static int jdvbt90502_read_signal_strength(struct dvb_frontend *fe,
+                                           u16 *strength)
+{
+        int ret;
+        u8 rbuf[37];
+
+        *strength = 0;
+
+        /* status register (incl. signal strength) : 0x89  */
+        /* TODO: read just the necessary registers [0x8B..0x8D]? */
+        ret = jdvbt90502_reg_read(fe->demodulator_priv, 0x0089,
+                                  rbuf, sizeof(rbuf));
+
+        if (ret) {
+                deb_fe("%s:ret == %d\n", __func__, ret);
+                return -EREMOTEIO;
+        }
+
+        /* signal_strength: rbuf[2-4] (24bit BE), use lower 16bit for now. */
+        *strength = (rbuf[3] << 8) + rbuf[4];
+        if (rbuf[2])
+                *strength = 0xffff;
+
+        return 0;
+}
+
+
+/* filter out un-supported properties to notify users */
+static int jdvbt90502_set_property(struct dvb_frontend *fe,
+                                   struct dtv_property *tvp)
+{
+        int r = 0;
+
+        switch (tvp->cmd) {
+        case DTV_DELIVERY_SYSTEM:
+                if (tvp->u.data != SYS_ISDBT)
+                        r = -EINVAL;
+                break;
+        case DTV_CLEAR:
+        case DTV_TUNE:
+        case DTV_FREQUENCY:
+                break;
+        default:
+                r = -EINVAL;
+        }
+        return r;
+}
+
+static int jdvbt90502_get_frontend(struct dvb_frontend *fe,
+                                   struct dvb_frontend_parameters *p)
+{
+        p->inversion = INVERSION_AUTO;
+        p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
+        p->u.ofdm.code_rate_HP = FEC_AUTO;
+        p->u.ofdm.code_rate_LP = FEC_AUTO;
+        p->u.ofdm.constellation = QAM_64;
+        p->u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
+        p->u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
+        p->u.ofdm.hierarchy_information = HIERARCHY_AUTO;
+        return 0;
+}
+
+static int jdvbt90502_set_frontend(struct dvb_frontend *fe,
+                                   struct dvb_frontend_parameters *p)
+{
+        /**
+         * NOTE: ignore all the parameters except frequency.
+         *       others should be fixed to the proper value for ISDB-T,
+         *       but don't check here.
+         */
+
+        struct jdvbt90502_state *state = fe->demodulator_priv;
+        int ret;
+
+        deb_fe("%s: Freq:%d\n", __func__, p->frequency);
+
+        /* for recovery from DTV_CLEAN */
+        fe->dtv_property_cache.delivery_system = SYS_ISDBT;
+
+        ret = jdvbt90502_pll_set_freq(state, p->frequency);
+        if (ret) {
+                deb_fe("%s:ret == %d\n", __func__, ret);
+                return -EREMOTEIO;
+        }
+
+        return 0;
+}
+
+
+/**
+ * (reg, val) commad list to initialize this module.
+ *  captured on a Windows box.
+ */
+static u8 init_code[][2] = {
+        {0x01, 0x40},
+        {0x04, 0x38},
+        {0x05, 0x40},
+        {0x07, 0x40},
+        {0x0F, 0x4F},
+        {0x11, 0x21},
+        {0x12, 0x0B},
+        {0x13, 0x2F},
+        {0x14, 0x31},
+        {0x16, 0x02},
+        {0x21, 0xC4},
+        {0x22, 0x20},
+        {0x2C, 0x79},
+        {0x2D, 0x34},
+        {0x2F, 0x00},
+        {0x30, 0x28},
+        {0x31, 0x31},
+        {0x32, 0xDF},
+        {0x38, 0x01},
+        {0x39, 0x78},
+        {0x3B, 0x33},
+        {0x3C, 0x33},
+        {0x48, 0x90},
+        {0x51, 0x68},
+        {0x5E, 0x38},
+        {0x71, 0x00},
+        {0x72, 0x08},
+        {0x77, 0x00},
+        {0xC0, 0x21},
+        {0xC1, 0x10},
+        {0xE4, 0x1A},
+        {0xEA, 0x1F},
+        {0x77, 0x00},
+        {0x71, 0x00},
+        {0x71, 0x00},
+        {0x76, 0x0C},
+};
+
+static const int init_code_len = sizeof(init_code) / sizeof(u8[2]);
+
+static int jdvbt90502_init(struct dvb_frontend *fe)
+{
+        int i = -1;
+        int ret;
+        struct i2c_msg msg;
+
+        struct jdvbt90502_state *state = fe->demodulator_priv;
+
+        deb_fe("%s called.\n", __func__);
+
+        msg.addr = state->config.demod_address;
+        msg.flags = 0;
+        msg.len = 2;
+        for (i = 0; i < init_code_len; i++) {
+                msg.buf = init_code[i];
+                ret = i2c_transfer(state->i2c, &msg, 1);
+                if (ret != 1)
+                        goto error;
+        }
+        fe->dtv_property_cache.delivery_system = SYS_ISDBT;
+        msleep(100);
+
+        return 0;
+
+error:
+        deb_fe("%s: init_code[%d] failed. ret==%d\n", __func__, i, ret);
+        return -EREMOTEIO;
+}
+
+
+static void jdvbt90502_release(struct dvb_frontend *fe)
+{
+        struct jdvbt90502_state *state = fe->demodulator_priv;
+        kfree(state);
+}
+
+
+static struct dvb_frontend_ops jdvbt90502_ops;
+
+struct dvb_frontend *jdvbt90502_attach(struct dvb_usb_device *d)
+{
+        struct jdvbt90502_state *state = NULL;
+
+        deb_info("%s called.\n", __func__);
+
+        /* allocate memory for the internal state */
+        state = kzalloc(sizeof(struct jdvbt90502_state), GFP_KERNEL);
+        if (state == NULL)
+                goto error;
+
+        /* setup the state */
+        state->i2c = &d->i2c_adap;
+        memcpy(&state->config, &friio_fe_config, sizeof(friio_fe_config));
+
+        /* create dvb_frontend */
+        memcpy(&state->frontend.ops, &jdvbt90502_ops,
+               sizeof(jdvbt90502_ops));
+        state->frontend.demodulator_priv = state;
+
+        if (jdvbt90502_init(&state->frontend) < 0)
+                goto error;
+
+        return &state->frontend;
+
+error:
+        kfree(state);
+        return NULL;
+}
+
+static struct dvb_frontend_ops jdvbt90502_ops = {
+
+        .info = {
+                .name                   = "Comtech JDVBT90502 ISDB-T",
+                .type                   = FE_OFDM,
+                .frequency_min          = 473000000, /* UHF 13ch, center */
+                .frequency_max          = 767142857, /* UHF 62ch, center */
+                .frequency_stepsize     = JDVBT90502_PLL_CLK /
+                                                        JDVBT90502_PLL_DIVIDER,
+                .frequency_tolerance    = 0,
+
+                /* NOTE: this driver ignores all parameters but frequency. */
+                .caps = FE_CAN_INVERSION_AUTO |
+                        FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                        FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
+                        FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO |
+                        FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
+                        FE_CAN_TRANSMISSION_MODE_AUTO |
+                        FE_CAN_GUARD_INTERVAL_AUTO |
+                        FE_CAN_HIERARCHY_AUTO,
+        },
+
+        .release = jdvbt90502_release,
+
+        .init = jdvbt90502_init,
+        .write = _jdvbt90502_write,
+
+        .set_property = jdvbt90502_set_property,
+
+        .set_frontend = jdvbt90502_set_frontend,
+        .get_frontend = jdvbt90502_get_frontend,
+
+        .read_status = jdvbt90502_read_status,
+        .read_signal_strength = jdvbt90502_read_signal_strength,
+};
diff --git a/drivers/media/dvb/dvb-usb/friio.c b/drivers/media/dvb/dvb-usb/friio.c
new file mode 100644
index 00000000000..76159aed9bb
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/friio.c
@@ -0,0 +1,540 @@
+/* DVB USB compliant Linux driver for the Friio USB2.0 ISDB-T receiver.
+ *
+ * Copyright (C) 2009 Akihiro Tsukada <tskd2@yahoo.co.jp>
+ *
+ * This module is based off the the gl861 and vp702x modules.
+ *
+ * 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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "friio.h"
+
+/* debug */
+int dvb_usb_friio_debug;
+module_param_named(debug, dvb_usb_friio_debug, int, 0644);
+MODULE_PARM_DESC(debug,
+                 "set debugging level (1=info,2=xfer,4=rc,8=fe (or-able))."
+                 DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+/**
+ * Indirect I2C access to the PLL via FE.
+ * whole I2C protocol data to the PLL is sent via the FE's I2C register.
+ * This is done by a control msg to the FE with the I2C data accompanied, and
+ * a specific USB request number is assigned for that purpose.
+ *
+ * this func sends wbuf[1..] to the I2C register wbuf[0] at addr (= at FE).
+ * TODO: refoctored, smarter i2c functions.
+ */
+static int gl861_i2c_ctrlmsg_data(struct dvb_usb_device *d, u8 addr,
+                                  u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        u16 index = wbuf[0];    /* must be JDVBT90502_2ND_I2C_REG(=0xFE) */
+        u16 value = addr << (8 + 1);
+        int wo = (rbuf == NULL || rlen == 0);   /* write only */
+        u8 req, type;
+
+        deb_xfer("write to PLL:0x%02x via FE reg:0x%02x, len:%d\n",
+                 wbuf[1], wbuf[0], wlen - 1);
+
+        if (wo && wlen >= 2) {
+                req = GL861_REQ_I2C_DATA_CTRL_WRITE;
+                type = GL861_WRITE;
+                udelay(20);
+                return usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                                       req, type, value, index,
+                                       &wbuf[1], wlen - 1, 2000);
+        }
+
+        deb_xfer("not supported ctrl-msg, aborting.");
+        return -EINVAL;
+}
+
+/* normal I2C access (without extra data arguments).
+ * write to the register wbuf[0] at I2C address addr with the value wbuf[1],
+ *  or read from the register wbuf[0].
+ * register address can be 16bit (wbuf[2]<<8 | wbuf[0]) if wlen==3
+ */
+static int gl861_i2c_msg(struct dvb_usb_device *d, u8 addr,
+                         u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        u16 index;
+        u16 value = addr << (8 + 1);
+        int wo = (rbuf == NULL || rlen == 0);   /* write-only */
+        u8 req, type;
+        unsigned int pipe;
+
+        /* special case for the indirect I2C access to the PLL via FE, */
+        if (addr == friio_fe_config.demod_address &&
+            wbuf[0] == JDVBT90502_2ND_I2C_REG)
+                return gl861_i2c_ctrlmsg_data(d, addr, wbuf, wlen, rbuf, rlen);
+
+        if (wo) {
+                req = GL861_REQ_I2C_WRITE;
+                type = GL861_WRITE;
+                pipe = usb_sndctrlpipe(d->udev, 0);
+        } else {                /* rw */
+                req = GL861_REQ_I2C_READ;
+                type = GL861_READ;
+                pipe = usb_rcvctrlpipe(d->udev, 0);
+        }
+
+        switch (wlen) {
+        case 1:
+                index = wbuf[0];
+                break;
+        case 2:
+                index = wbuf[0];
+                value = value + wbuf[1];
+                break;
+        case 3:
+                /* special case for 16bit register-address */
+                index = (wbuf[2] << 8) | wbuf[0];
+                value = value + wbuf[1];
+                break;
+        default:
+                deb_xfer("wlen = %x, aborting.", wlen);
+                return -EINVAL;
+        }
+        msleep(1);
+        return usb_control_msg(d->udev, pipe, req, type,
+                               value, index, rbuf, rlen, 2000);
+}
+
+/* I2C */
+static int gl861_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                          int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i;
+
+
+        if (num > 2)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                /* write/read request */
+                if (i + 1 < num && (msg[i + 1].flags & I2C_M_RD)) {
+                        if (gl861_i2c_msg(d, msg[i].addr,
+                                          msg[i].buf, msg[i].len,
+                                          msg[i + 1].buf, msg[i + 1].len) < 0)
+                                break;
+                        i++;
+                } else
+                        if (gl861_i2c_msg(d, msg[i].addr, msg[i].buf,
+                                          msg[i].len, NULL, 0) < 0)
+                                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+static u32 gl861_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static int friio_ext_ctl(struct dvb_usb_adapter *adap,
+                         u32 sat_color, int lnb_on)
+{
+        int i;
+        int ret;
+        struct i2c_msg msg;
+        u8 *buf;
+        u32 mask;
+        u8 lnb = (lnb_on) ? FRIIO_CTL_LNB : 0;
+
+        buf = kmalloc(2, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        msg.addr = 0x00;
+        msg.flags = 0;
+        msg.len = 2;
+        msg.buf = buf;
+
+        buf[0] = 0x00;
+
+        /* send 2bit header (&B10) */
+        buf[1] = lnb | FRIIO_CTL_LED | FRIIO_CTL_STROBE;
+        ret = gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+        buf[1] |= FRIIO_CTL_CLK;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+
+        buf[1] = lnb | FRIIO_CTL_STROBE;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+        buf[1] |= FRIIO_CTL_CLK;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+
+        /* send 32bit(satur, R, G, B) data in serial */
+        mask = 1 << 31;
+        for (i = 0; i < 32; i++) {
+                buf[1] = lnb | FRIIO_CTL_STROBE;
+                if (sat_color & mask)
+                        buf[1] |= FRIIO_CTL_LED;
+                ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+                buf[1] |= FRIIO_CTL_CLK;
+                ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+                mask >>= 1;
+        }
+
+        /* set the strobe off */
+        buf[1] = lnb;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+        buf[1] |= FRIIO_CTL_CLK;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+
+        kfree(buf);
+        return (ret == 70);
+}
+
+
+static int friio_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff);
+
+/* TODO: move these init cmds to the FE's init routine? */
+static u8 streaming_init_cmds[][2] = {
+        {0x33, 0x08},
+        {0x37, 0x40},
+        {0x3A, 0x1F},
+        {0x3B, 0xFF},
+        {0x3C, 0x1F},
+        {0x3D, 0xFF},
+        {0x38, 0x00},
+        {0x35, 0x00},
+        {0x39, 0x00},
+        {0x36, 0x00},
+};
+static int cmdlen = sizeof(streaming_init_cmds) / 2;
+
+/*
+ * Command sequence in this init function is a replay
+ *  of the captured USB commands from the Windows proprietary driver.
+ */
+static int friio_initialize(struct dvb_usb_device *d)
+{
+        int ret;
+        int i;
+        int retry = 0;
+        u8 *rbuf, *wbuf;
+
+        deb_info("%s called.\n", __func__);
+
+        wbuf = kmalloc(3, GFP_KERNEL);
+        if (!wbuf)
+                return -ENOMEM;
+
+        rbuf = kmalloc(2, GFP_KERNEL);
+        if (!rbuf) {
+                kfree(wbuf);
+                return -ENOMEM;
+        }
+
+        /* use gl861_i2c_msg instead of gl861_i2c_xfer(), */
+        /* because the i2c device is not set up yet. */
+        wbuf[0] = 0x11;
+        wbuf[1] = 0x02;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+        msleep(2);
+
+        wbuf[0] = 0x11;
+        wbuf[1] = 0x00;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+        msleep(1);
+
+        /* following msgs should be in the FE's init code? */
+        /* cmd sequence to identify the device type? (friio black/white) */
+        wbuf[0] = 0x03;
+        wbuf[1] = 0x80;
+        /* can't use gl861_i2c_cmd, as the register-addr is 16bit(0x0100) */
+        ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                              GL861_REQ_I2C_DATA_CTRL_WRITE, GL861_WRITE,
+                              0x1200, 0x0100, wbuf, 2, 2000);
+        if (ret < 0)
+                goto error;
+
+        msleep(2);
+        wbuf[0] = 0x00;
+        wbuf[2] = 0x01;         /* reg.0x0100 */
+        wbuf[1] = 0x00;
+        ret = gl861_i2c_msg(d, 0x12 >> 1, wbuf, 3, rbuf, 2);
+        /* my Friio White returns 0xffff. */
+        if (ret < 0 || rbuf[0] != 0xff || rbuf[1] != 0xff)
+                goto error;
+
+        msleep(2);
+        wbuf[0] = 0x03;
+        wbuf[1] = 0x80;
+        ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                              GL861_REQ_I2C_DATA_CTRL_WRITE, GL861_WRITE,
+                              0x9000, 0x0100, wbuf, 2, 2000);
+        if (ret < 0)
+                goto error;
+
+        msleep(2);
+        wbuf[0] = 0x00;
+        wbuf[2] = 0x01;         /* reg.0x0100 */
+        wbuf[1] = 0x00;
+        ret = gl861_i2c_msg(d, 0x90 >> 1, wbuf, 3, rbuf, 2);
+        /* my Friio White returns 0xffff again. */
+        if (ret < 0 || rbuf[0] != 0xff || rbuf[1] != 0xff)
+                goto error;
+
+        msleep(1);
+
+restart:
+        /* ============ start DEMOD init cmds ================== */
+        /* read PLL status to clear the POR bit */
+        wbuf[0] = JDVBT90502_2ND_I2C_REG;
+        wbuf[1] = (FRIIO_PLL_ADDR << 1) + 1;    /* +1 for reading */
+        ret = gl861_i2c_msg(d, FRIIO_DEMOD_ADDR, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+
+        msleep(5);
+        /* note: DEMODULATOR has 16bit register-address. */
+        wbuf[0] = 0x00;
+        wbuf[2] = 0x01;         /* reg addr: 0x0100 */
+        wbuf[1] = 0x00;         /* val: not used */
+        ret = gl861_i2c_msg(d, FRIIO_DEMOD_ADDR, wbuf, 3, rbuf, 1);
+        if (ret < 0)
+                goto error;
+/*
+        msleep(1);
+        wbuf[0] = 0x80;
+        wbuf[1] = 0x00;
+        ret = gl861_i2c_msg(d, FRIIO_DEMOD_ADDR, wbuf, 2, rbuf, 1);
+        if (ret < 0)
+                goto error;
+ */
+        if (rbuf[0] & 0x80) {   /* still in PowerOnReset state? */
+                if (++retry > 3) {
+                        deb_info("failed to get the correct"
+                                 " FE demod status:0x%02x\n", rbuf[0]);
+                        goto error;
+                }
+                msleep(100);
+                goto restart;
+        }
+
+        /* TODO: check return value in rbuf */
+        /* =========== end DEMOD init cmds ===================== */
+        msleep(1);
+
+        wbuf[0] = 0x30;
+        wbuf[1] = 0x04;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+
+        msleep(2);
+        /* following 2 cmds unnecessary? */
+        wbuf[0] = 0x00;
+        wbuf[1] = 0x01;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+
+        wbuf[0] = 0x06;
+        wbuf[1] = 0x0F;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+
+        /* some streaming ctl cmds (maybe) */
+        msleep(10);
+        for (i = 0; i < cmdlen; i++) {
+                ret = gl861_i2c_msg(d, 0x00, streaming_init_cmds[i], 2,
+                                    NULL, 0);
+                if (ret < 0)
+                        goto error;
+                msleep(1);
+        }
+        msleep(20);
+
+        /* change the LED color etc. */
+        ret = friio_streaming_ctrl(&d->adapter[0], 0);
+        if (ret < 0)
+                goto error;
+
+        return 0;
+
+error:
+        kfree(wbuf);
+        kfree(rbuf);
+        deb_info("%s:ret == %d\n", __func__, ret);
+        return -EIO;
+}
+
+/* Callbacks for DVB USB */
+
+static int friio_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        int ret;
+
+        deb_info("%s called.(%d)\n", __func__, onoff);
+
+        /* set the LED color and saturation (and LNB on) */
+        if (onoff)
+                ret = friio_ext_ctl(adap, 0x6400ff64, 1);
+        else
+                ret = friio_ext_ctl(adap, 0x96ff00ff, 1);
+
+        if (ret != 1) {
+                deb_info("%s failed to send cmdx. ret==%d\n", __func__, ret);
+                return -EREMOTEIO;
+        }
+        return 0;
+}
+
+static int friio_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (friio_initialize(adap->dev) < 0)
+                return -EIO;
+
+        adap->fe = jdvbt90502_attach(adap->dev);
+        if (adap->fe == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties friio_properties;
+
+static int friio_probe(struct usb_interface *intf,
+                       const struct usb_device_id *id)
+{
+        struct dvb_usb_device *d;
+        struct usb_host_interface *alt;
+        int ret;
+
+        if (intf->num_altsetting < GL861_ALTSETTING_COUNT)
+                return -ENODEV;
+
+        alt = usb_altnum_to_altsetting(intf, FRIIO_BULK_ALTSETTING);
+        if (alt == NULL) {
+                deb_rc("not alt found!\n");
+                return -ENODEV;
+        }
+        ret = usb_set_interface(interface_to_usbdev(intf),
+                                alt->desc.bInterfaceNumber,
+                                alt->desc.bAlternateSetting);
+        if (ret != 0) {
+                deb_rc("failed to set alt-setting!\n");
+                return ret;
+        }
+
+        ret = dvb_usb_device_init(intf, &friio_properties,
+                                  THIS_MODULE, &d, adapter_nr);
+        if (ret == 0)
+                friio_streaming_ctrl(&d->adapter[0], 1);
+
+        return ret;
+}
+
+
+struct jdvbt90502_config friio_fe_config = {
+        .demod_address = FRIIO_DEMOD_ADDR,
+        .pll_address = FRIIO_PLL_ADDR,
+};
+
+static struct i2c_algorithm gl861_i2c_algo = {
+        .master_xfer   = gl861_i2c_xfer,
+        .functionality = gl861_i2c_func,
+};
+
+static struct usb_device_id friio_table[] = {
+        { USB_DEVICE(USB_VID_774, USB_PID_FRIIO_WHITE) },
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, friio_table);
+
+
+static struct dvb_usb_device_properties friio_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+
+        .size_of_priv = 0,
+
+        .num_adapters = 1,
+        .adapter = {
+                /* caps:0 =>  no pid filter, 188B TS packet */
+                /* GL861 has a HW pid filter, but no info available. */
+                {
+                        .caps  = 0,
+
+                        .frontend_attach  = friio_frontend_attach,
+                        .streaming_ctrl = friio_streaming_ctrl,
+
+                        .stream = {
+                                .type = USB_BULK,
+                                /* count <= MAX_NO_URBS_FOR_DATA_STREAM(10) */
+                                .count = 8,
+                                .endpoint = 0x01,
+                                .u = {
+                                        /* GL861 has 6KB buf inside */
+                                        .bulk = {
+                                                .buffersize = 16384,
+                                        }
+                                }
+                        },
+                }
+        },
+        .i2c_algo = &gl861_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        .name = "774 Friio ISDB-T USB2.0",
+                        .cold_ids = { NULL },
+                        .warm_ids = { &friio_table[0], NULL },
+                },
+        }
+};
+
+static struct usb_driver friio_driver = {
+        .name           = "dvb_usb_friio",
+        .probe          = friio_probe,
+        .disconnect     = dvb_usb_device_exit,
+        .id_table       = friio_table,
+};
+
+
+/* module stuff */
+static int __init friio_module_init(void)
+{
+        int ret;
+
+        ret = usb_register(&friio_driver);
+        if (ret)
+                err("usb_register failed. Error number %d", ret);
+
+        return ret;
+}
+
+
+static void __exit friio_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&friio_driver);
+}
+
+module_init(friio_module_init);
+module_exit(friio_module_exit);
+
+MODULE_AUTHOR("Akihiro Tsukada <tskd2@yahoo.co.jp>");
+MODULE_DESCRIPTION("Driver for Friio ISDB-T USB2.0 Receiver");
+MODULE_VERSION("0.2");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/friio.h b/drivers/media/dvb/dvb-usb/friio.h
new file mode 100644
index 00000000000..0f461ca10cb
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/friio.h
@@ -0,0 +1,99 @@
+/* DVB USB compliant Linux driver for the Friio USB2.0 ISDB-T receiver.
+ *
+ * Copyright (C) 2009 Akihiro Tsukada <tskd2@yahoo.co.jp>
+ *
+ * This module is based off the the gl861 and vp702x modules.
+ *
+ * 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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_FRIIO_H_
+#define _DVB_USB_FRIIO_H_
+
+/**
+ *      Friio Components
+ *       USB hub:                                AU4254
+ *         USB controller(+ TS dmx & streaming): GL861
+ *         Frontend:                             comtech JDVBT-90502
+ *             (tuner PLL:                       tua6034, I2C addr:(0xC0 >> 1))
+ *             (OFDM demodulator:                TC90502, I2C addr:(0x30 >> 1))
+ *         LED x3 (+LNB) control:                PIC 16F676
+ *         EEPROM:                               24C08
+ *
+ *        (USB smart card reader:                AU9522)
+ *
+ */
+
+#define DVB_USB_LOG_PREFIX "friio"
+#include "dvb-usb.h"
+
+extern int dvb_usb_friio_debug;
+#define deb_info(args...) dprintk(dvb_usb_friio_debug, 0x01, args)
+#define deb_xfer(args...) dprintk(dvb_usb_friio_debug, 0x02, args)
+#define deb_rc(args...)   dprintk(dvb_usb_friio_debug, 0x04, args)
+#define deb_fe(args...)   dprintk(dvb_usb_friio_debug, 0x08, args)
+
+/* Vendor requests */
+#define GL861_WRITE             0x40
+#define GL861_READ              0xc0
+
+/* command bytes */
+#define GL861_REQ_I2C_WRITE     0x01
+#define GL861_REQ_I2C_READ      0x02
+/* For control msg with data argument */
+/* Used for accessing the PLL on the secondary I2C bus of FE via GL861 */
+#define GL861_REQ_I2C_DATA_CTRL_WRITE   0x03
+
+#define GL861_ALTSETTING_COUNT  2
+#define FRIIO_BULK_ALTSETTING   0
+#define FRIIO_ISOC_ALTSETTING   1
+
+/* LED & LNB control via PIC. */
+/* basically, it's serial control with clock and strobe. */
+/* write the below 4bit control data to the reg 0x00 at the I2C addr 0x00 */
+/* when controlling the LEDs, 32bit(saturation, R, G, B) is sent on the bit3*/
+#define FRIIO_CTL_LNB (1 << 0)
+#define FRIIO_CTL_STROBE (1 << 1)
+#define FRIIO_CTL_CLK (1 << 2)
+#define FRIIO_CTL_LED (1 << 3)
+
+/* Front End related */
+
+#define FRIIO_DEMOD_ADDR  (0x30 >> 1)
+#define FRIIO_PLL_ADDR  (0xC0 >> 1)
+
+#define JDVBT90502_PLL_CLK      4000000
+#define JDVBT90502_PLL_DIVIDER  28
+
+#define JDVBT90502_2ND_I2C_REG 0xFE
+
+/* byte index for pll i2c command data structure*/
+/* see datasheet for tua6034 */
+#define DEMOD_REDIRECT_REG 0
+#define ADDRESS_BYTE       1
+#define DIVIDER_BYTE1      2
+#define DIVIDER_BYTE2      3
+#define CONTROL_BYTE       4
+#define BANDSWITCH_BYTE    5
+#define AGC_CTRL_BYTE      5
+#define PLL_CMD_LEN        6
+
+/* bit masks for PLL STATUS response */
+#define PLL_STATUS_POR_MODE   0x80 /* 1: Power on Reset (test) Mode */
+#define PLL_STATUS_LOCKED     0x40 /* 1: locked */
+#define PLL_STATUS_AGC_ACTIVE 0x08 /* 1:active */
+#define PLL_STATUS_TESTMODE   0x07 /* digital output level (5 level) */
+  /* 0.15Vcc step   0x00: < 0.15Vcc, ..., 0x04: >= 0.6Vcc (<= 1Vcc) */
+
+
+struct jdvbt90502_config {
+        u8 demod_address; /* i2c addr for demodulator IC */
+        u8 pll_address;   /* PLL addr on the secondary i2c*/
+};
+extern struct jdvbt90502_config friio_fe_config;
+
+extern struct dvb_frontend *jdvbt90502_attach(struct dvb_usb_device *d);
+#endif
diff --git a/drivers/media/dvb/dvb-usb/gl861.c b/drivers/media/dvb/dvb-usb/gl861.c
new file mode 100644
index 00000000000..6f596ed4176
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/gl861.c
@@ -0,0 +1,233 @@
+/* DVB USB compliant linux driver for GL861 USB2.0 devices.
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "gl861.h"
+
+#include "zl10353.h"
+#include "qt1010.h"
+
+/* debug */
+static int dvb_usb_gl861_debug;
+module_param_named(debug, dvb_usb_gl861_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))."
+        DVB_USB_DEBUG_STATUS);
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int gl861_i2c_msg(struct dvb_usb_device *d, u8 addr,
+                         u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        u16 index;
+        u16 value = addr << (8 + 1);
+        int wo = (rbuf == NULL || rlen == 0); /* write-only */
+        u8 req, type;
+
+        if (wo) {
+                req = GL861_REQ_I2C_WRITE;
+                type = GL861_WRITE;
+        } else { /* rw */
+                req = GL861_REQ_I2C_READ;
+                type = GL861_READ;
+        }
+
+        switch (wlen) {
+        case 1:
+                index = wbuf[0];
+                break;
+        case 2:
+                index = wbuf[0];
+                value = value + wbuf[1];
+                break;
+        default:
+                warn("wlen = %x, aborting.", wlen);
+                return -EINVAL;
+        }
+
+        msleep(1); /* avoid I2C errors */
+
+        return usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0), req, type,
+                               value, index, rbuf, rlen, 2000);
+}
+
+/* I2C */
+static int gl861_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                          int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i;
+
+        if (num > 2)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                /* write/read request */
+                if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
+                        if (gl861_i2c_msg(d, msg[i].addr, msg[i].buf,
+                                msg[i].len, msg[i+1].buf, msg[i+1].len) < 0)
+                                break;
+                        i++;
+                } else
+                        if (gl861_i2c_msg(d, msg[i].addr, msg[i].buf,
+                                          msg[i].len, NULL, 0) < 0)
+                                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+static u32 gl861_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm gl861_i2c_algo = {
+        .master_xfer   = gl861_i2c_xfer,
+        .functionality = gl861_i2c_func,
+};
+
+/* Callbacks for DVB USB */
+static struct zl10353_config gl861_zl10353_config = {
+        .demod_address = 0x0f,
+        .no_tuner = 1,
+        .parallel_ts = 1,
+};
+
+static int gl861_frontend_attach(struct dvb_usb_adapter *adap)
+{
+
+        adap->fe = dvb_attach(zl10353_attach, &gl861_zl10353_config,
+                &adap->dev->i2c_adap);
+        if (adap->fe == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+static struct qt1010_config gl861_qt1010_config = {
+        .i2c_address = 0x62
+};
+
+static int gl861_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        return dvb_attach(qt1010_attach,
+                          adap->fe, &adap->dev->i2c_adap,
+                          &gl861_qt1010_config) == NULL ? -ENODEV : 0;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties gl861_properties;
+
+static int gl861_probe(struct usb_interface *intf,
+                       const struct usb_device_id *id)
+{
+        struct dvb_usb_device *d;
+        struct usb_host_interface *alt;
+        int ret;
+
+        if (intf->num_altsetting < 2)
+                return -ENODEV;
+
+        ret = dvb_usb_device_init(intf, &gl861_properties, THIS_MODULE, &d,
+                                  adapter_nr);
+        if (ret == 0) {
+                alt = usb_altnum_to_altsetting(intf, 0);
+
+                if (alt == NULL) {
+                        deb_rc("not alt found!\n");
+                        return -ENODEV;
+                }
+
+                ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
+                                        alt->desc.bAlternateSetting);
+        }
+
+        return ret;
+}
+
+static struct usb_device_id gl861_table [] = {
+                { USB_DEVICE(USB_VID_MSI, USB_PID_MSI_MEGASKY580_55801) },
+                { USB_DEVICE(USB_VID_ALINK, USB_VID_ALINK_DTU) },
+                { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, gl861_table);
+
+static struct dvb_usb_device_properties gl861_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+
+        .size_of_priv     = 0,
+
+        .num_adapters = 1,
+        .adapter = {{
+
+                .frontend_attach  = gl861_frontend_attach,
+                .tuner_attach     = gl861_tuner_attach,
+
+                .stream = {
+                        .type = USB_BULK,
+                        .count = 7,
+                        .endpoint = 0x81,
+                        .u = {
+                                .bulk = {
+                                        .buffersize = 512,
+                                }
+                        }
+                },
+        } },
+        .i2c_algo         = &gl861_i2c_algo,
+
+        .num_device_descs = 2,
+        .devices = {
+                {
+                        .name = "MSI Mega Sky 55801 DVB-T USB2.0",
+                        .cold_ids = { NULL },
+                        .warm_ids = { &gl861_table[0], NULL },
+                },
+                {
+                        .name = "A-LINK DTU DVB-T USB2.0",
+                        .cold_ids = { NULL },
+                        .warm_ids = { &gl861_table[1], NULL },
+                },
+        }
+};
+
+static struct usb_driver gl861_driver = {
+        .name           = "dvb_usb_gl861",
+        .probe          = gl861_probe,
+        .disconnect     = dvb_usb_device_exit,
+        .id_table       = gl861_table,
+};
+
+/* module stuff */
+static int __init gl861_module_init(void)
+{
+        int ret;
+
+        ret = usb_register(&gl861_driver);
+        if (ret)
+                err("usb_register failed. Error number %d", ret);
+
+        return ret;
+}
+
+static void __exit gl861_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&gl861_driver);
+}
+
+module_init(gl861_module_init);
+module_exit(gl861_module_exit);
+
+MODULE_AUTHOR("Carl Lundqvist <comabug@gmail.com>");
+MODULE_DESCRIPTION("Driver MSI Mega Sky 580 DVB-T USB2.0 / GL861");
+MODULE_VERSION("0.1");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/gl861.h b/drivers/media/dvb/dvb-usb/gl861.h
new file mode 100644
index 00000000000..c54855e2c23
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/gl861.h
@@ -0,0 +1,15 @@
+#ifndef _DVB_USB_GL861_H_
+#define _DVB_USB_GL861_H_
+
+#define DVB_USB_LOG_PREFIX "gl861"
+#include "dvb-usb.h"
+
+#define deb_rc(args...)   dprintk(dvb_usb_gl861_debug, 0x01, args)
+
+#define GL861_WRITE             0x40
+#define GL861_READ              0xc0
+
+#define GL861_REQ_I2C_WRITE     0x01
+#define GL861_REQ_I2C_READ      0x02
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/gp8psk-fe.c b/drivers/media/dvb/dvb-usb/gp8psk-fe.c
new file mode 100644
index 00000000000..60d11e57e7d
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/gp8psk-fe.c
@@ -0,0 +1,378 @@
+/* DVB USB compliant Linux driver for the
+ *  - GENPIX 8pks/qpsk/DCII USB2.0 DVB-S module
+ *
+ * Copyright (C) 2006,2007 Alan Nisota (alannisota@gmail.com)
+ * Copyright (C) 2006,2007 Genpix Electronics (genpix@genpix-electronics.com)
+ *
+ * Thanks to GENPIX for the sample code used to implement this module.
+ *
+ * This module is based off the vp7045 and vp702x modules
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "gp8psk.h"
+
+struct gp8psk_fe_state {
+        struct dvb_frontend fe;
+        struct dvb_usb_device *d;
+        u8 lock;
+        u16 snr;
+        unsigned long next_status_check;
+        unsigned long status_check_interval;
+};
+
+static int gp8psk_tuned_to_DCII(struct dvb_frontend *fe)
+{
+        struct gp8psk_fe_state *st = fe->demodulator_priv;
+        u8 status;
+        gp8psk_usb_in_op(st->d, GET_8PSK_CONFIG, 0, 0, &status, 1);
+        return status & bmDCtuned;
+}
+
+static int gp8psk_set_tuner_mode(struct dvb_frontend *fe, int mode)
+{
+        struct gp8psk_fe_state *state = fe->demodulator_priv;
+        return gp8psk_usb_out_op(state->d, SET_8PSK_CONFIG, mode, 0, NULL, 0);
+}
+
+static int gp8psk_fe_update_status(struct gp8psk_fe_state *st)
+{
+        u8 buf[6];
+        if (time_after(jiffies,st->next_status_check)) {
+                gp8psk_usb_in_op(st->d, GET_SIGNAL_LOCK, 0,0,&st->lock,1);
+                gp8psk_usb_in_op(st->d, GET_SIGNAL_STRENGTH, 0,0,buf,6);
+                st->snr = (buf[1]) << 8 | buf[0];
+                st->next_status_check = jiffies + (st->status_check_interval*HZ)/1000;
+        }
+        return 0;
+}
+
+static int gp8psk_fe_read_status(struct dvb_frontend* fe, fe_status_t *status)
+{
+        struct gp8psk_fe_state *st = fe->demodulator_priv;
+        gp8psk_fe_update_status(st);
+
+        if (st->lock)
+                *status = FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_SIGNAL | FE_HAS_CARRIER;
+        else
+                *status = 0;
+
+        if (*status & FE_HAS_LOCK)
+                st->status_check_interval = 1000;
+        else
+                st->status_check_interval = 100;
+        return 0;
+}
+
+/* not supported by this Frontend */
+static int gp8psk_fe_read_ber(struct dvb_frontend* fe, u32 *ber)
+{
+        (void) fe;
+        *ber = 0;
+        return 0;
+}
+
+/* not supported by this Frontend */
+static int gp8psk_fe_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
+{
+        (void) fe;
+        *unc = 0;
+        return 0;
+}
+
+static int gp8psk_fe_read_snr(struct dvb_frontend* fe, u16 *snr)
+{
+        struct gp8psk_fe_state *st = fe->demodulator_priv;
+        gp8psk_fe_update_status(st);
+        /* snr is reported in dBu*256 */
+        *snr = st->snr;
+        return 0;
+}
+
+static int gp8psk_fe_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
+{
+        struct gp8psk_fe_state *st = fe->demodulator_priv;
+        gp8psk_fe_update_status(st);
+        /* snr is reported in dBu*256 */
+        /* snr / 38.4 ~= 100% strength */
+        /* snr * 17 returns 100% strength as 65535 */
+        if (st->snr > 0xf00)
+                *strength = 0xffff;
+        else
+                *strength = (st->snr << 4) + st->snr; /* snr*17 */
+        return 0;
+}
+
+static int gp8psk_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 800;
+        return 0;
+}
+
+static int gp8psk_fe_set_property(struct dvb_frontend *fe,
+        struct dtv_property *tvp)
+{
+        deb_fe("%s(..)\n", __func__);
+        return 0;
+}
+
+static int gp8psk_fe_get_property(struct dvb_frontend *fe,
+        struct dtv_property *tvp)
+{
+        deb_fe("%s(..)\n", __func__);
+        return 0;
+}
+
+
+static int gp8psk_fe_set_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct gp8psk_fe_state *state = fe->demodulator_priv;
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+        u8 cmd[10];
+        u32 freq = fep->frequency * 1000;
+        int gp_product_id = le16_to_cpu(state->d->udev->descriptor.idProduct);
+
+        deb_fe("%s()\n", __func__);
+
+        cmd[4] = freq         & 0xff;
+        cmd[5] = (freq >> 8)  & 0xff;
+        cmd[6] = (freq >> 16) & 0xff;
+        cmd[7] = (freq >> 24) & 0xff;
+
+        switch (c->delivery_system) {
+        case SYS_DVBS:
+                /* Allow QPSK and 8PSK (even for DVB-S) */
+                if (c->modulation != QPSK && c->modulation != PSK_8) {
+                        deb_fe("%s: unsupported modulation selected (%d)\n",
+                                __func__, c->modulation);
+                        return -EOPNOTSUPP;
+                }
+                c->fec_inner = FEC_AUTO;
+                break;
+        case SYS_DVBS2:
+                deb_fe("%s: DVB-S2 delivery system selected\n", __func__);
+                break;
+
+        default:
+                deb_fe("%s: unsupported delivery system selected (%d)\n",
+                        __func__, c->delivery_system);
+                return -EOPNOTSUPP;
+        }
+
+        cmd[0] =  c->symbol_rate        & 0xff;
+        cmd[1] = (c->symbol_rate >>  8) & 0xff;
+        cmd[2] = (c->symbol_rate >> 16) & 0xff;
+        cmd[3] = (c->symbol_rate >> 24) & 0xff;
+        switch (c->modulation) {
+        case QPSK:
+                if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
+                        if (gp8psk_tuned_to_DCII(fe))
+                                gp8psk_bcm4500_reload(state->d);
+                switch (c->fec_inner) {
+                case FEC_1_2:
+                        cmd[9] = 0; break;
+                case FEC_2_3:
+                        cmd[9] = 1; break;
+                case FEC_3_4:
+                        cmd[9] = 2; break;
+                case FEC_5_6:
+                        cmd[9] = 3; break;
+                case FEC_7_8:
+                        cmd[9] = 4; break;
+                case FEC_AUTO:
+                        cmd[9] = 5; break;
+                default:
+                        cmd[9] = 5; break;
+                }
+                cmd[8] = ADV_MOD_DVB_QPSK;
+                break;
+        case PSK_8: /* PSK_8 is for compatibility with DN */
+                cmd[8] = ADV_MOD_TURBO_8PSK;
+                switch (c->fec_inner) {
+                case FEC_2_3:
+                        cmd[9] = 0; break;
+                case FEC_3_4:
+                        cmd[9] = 1; break;
+                case FEC_3_5:
+                        cmd[9] = 2; break;
+                case FEC_5_6:
+                        cmd[9] = 3; break;
+                case FEC_8_9:
+                        cmd[9] = 4; break;
+                default:
+                        cmd[9] = 0; break;
+                }
+                break;
+        case QAM_16: /* QAM_16 is for compatibility with DN */
+                cmd[8] = ADV_MOD_TURBO_16QAM;
+                cmd[9] = 0;
+                break;
+        default: /* Unknown modulation */
+                deb_fe("%s: unsupported modulation selected (%d)\n",
+                        __func__, c->modulation);
+                return -EOPNOTSUPP;
+        }
+
+        if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
+                gp8psk_set_tuner_mode(fe, 0);
+        gp8psk_usb_out_op(state->d, TUNE_8PSK, 0, 0, cmd, 10);
+
+        state->lock = 0;
+        state->next_status_check = jiffies;
+        state->status_check_interval = 200;
+
+        return 0;
+}
+
+static int gp8psk_fe_send_diseqc_msg (struct dvb_frontend* fe,
+                                    struct dvb_diseqc_master_cmd *m)
+{
+        struct gp8psk_fe_state *st = fe->demodulator_priv;
+
+        deb_fe("%s\n",__func__);
+
+        if (gp8psk_usb_out_op(st->d,SEND_DISEQC_COMMAND, m->msg[0], 0,
+                        m->msg, m->msg_len)) {
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int gp8psk_fe_send_diseqc_burst (struct dvb_frontend* fe,
+                                    fe_sec_mini_cmd_t burst)
+{
+        struct gp8psk_fe_state *st = fe->demodulator_priv;
+        u8 cmd;
+
+        deb_fe("%s\n",__func__);
+
+        /* These commands are certainly wrong */
+        cmd = (burst == SEC_MINI_A) ? 0x00 : 0x01;
+
+        if (gp8psk_usb_out_op(st->d,SEND_DISEQC_COMMAND, cmd, 0,
+                        &cmd, 0)) {
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int gp8psk_fe_set_tone (struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
+{
+        struct gp8psk_fe_state* state = fe->demodulator_priv;
+
+        if (gp8psk_usb_out_op(state->d,SET_22KHZ_TONE,
+                 (tone == SEC_TONE_ON), 0, NULL, 0)) {
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int gp8psk_fe_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltage)
+{
+        struct gp8psk_fe_state* state = fe->demodulator_priv;
+
+        if (gp8psk_usb_out_op(state->d,SET_LNB_VOLTAGE,
+                         voltage == SEC_VOLTAGE_18, 0, NULL, 0)) {
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int gp8psk_fe_enable_high_lnb_voltage(struct dvb_frontend* fe, long onoff)
+{
+        struct gp8psk_fe_state* state = fe->demodulator_priv;
+        return gp8psk_usb_out_op(state->d, USE_EXTRA_VOLT, onoff, 0,NULL,0);
+}
+
+static int gp8psk_fe_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long sw_cmd)
+{
+        struct gp8psk_fe_state* state = fe->demodulator_priv;
+        u8 cmd = sw_cmd & 0x7f;
+
+        if (gp8psk_usb_out_op(state->d,SET_DN_SWITCH, cmd, 0,
+                        NULL, 0)) {
+                return -EINVAL;
+        }
+        if (gp8psk_usb_out_op(state->d,SET_LNB_VOLTAGE, !!(sw_cmd & 0x80),
+                        0, NULL, 0)) {
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void gp8psk_fe_release(struct dvb_frontend* fe)
+{
+        struct gp8psk_fe_state *state = fe->demodulator_priv;
+        kfree(state);
+}
+
+static struct dvb_frontend_ops gp8psk_fe_ops;
+
+struct dvb_frontend * gp8psk_fe_attach(struct dvb_usb_device *d)
+{
+        struct gp8psk_fe_state *s = kzalloc(sizeof(struct gp8psk_fe_state), GFP_KERNEL);
+        if (s == NULL)
+                goto error;
+
+        s->d = d;
+        memcpy(&s->fe.ops, &gp8psk_fe_ops, sizeof(struct dvb_frontend_ops));
+        s->fe.demodulator_priv = s;
+
+        goto success;
+error:
+        return NULL;
+success:
+        return &s->fe;
+}
+
+
+static struct dvb_frontend_ops gp8psk_fe_ops = {
+        .info = {
+                .name                   = "Genpix DVB-S",
+                .type                   = FE_QPSK,
+                .frequency_min          = 800000,
+                .frequency_max          = 2250000,
+                .frequency_stepsize     = 100,
+                .symbol_rate_min        = 1000000,
+                .symbol_rate_max        = 45000000,
+                .symbol_rate_tolerance  = 500,  /* ppm */
+                .caps = FE_CAN_INVERSION_AUTO |
+                        FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                        FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
+                        /*
+                         * FE_CAN_QAM_16 is for compatibility
+                         * (Myth incorrectly detects Turbo-QPSK as plain QAM-16)
+                         */
+                        FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_TURBO_FEC
+        },
+
+        .release = gp8psk_fe_release,
+
+        .init = NULL,
+        .sleep = NULL,
+
+        .set_property = gp8psk_fe_set_property,
+        .get_property = gp8psk_fe_get_property,
+        .set_frontend = gp8psk_fe_set_frontend,
+
+        .get_tune_settings = gp8psk_fe_get_tune_settings,
+
+        .read_status = gp8psk_fe_read_status,
+        .read_ber = gp8psk_fe_read_ber,
+        .read_signal_strength = gp8psk_fe_read_signal_strength,
+        .read_snr = gp8psk_fe_read_snr,
+        .read_ucblocks = gp8psk_fe_read_unc_blocks,
+
+        .diseqc_send_master_cmd = gp8psk_fe_send_diseqc_msg,
+        .diseqc_send_burst = gp8psk_fe_send_diseqc_burst,
+        .set_tone = gp8psk_fe_set_tone,
+        .set_voltage = gp8psk_fe_set_voltage,
+        .dishnetwork_send_legacy_command = gp8psk_fe_send_legacy_dish_cmd,
+        .enable_high_lnb_voltage = gp8psk_fe_enable_high_lnb_voltage
+};
diff --git a/drivers/media/dvb/dvb-usb/gp8psk.c b/drivers/media/dvb/dvb-usb/gp8psk.c
new file mode 100644
index 00000000000..1cb3d9a66e0
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/gp8psk.c
@@ -0,0 +1,344 @@
+/* DVB USB compliant Linux driver for the
+ *  - GENPIX 8pks/qpsk/DCII USB2.0 DVB-S module
+ *
+ * Copyright (C) 2006,2007 Alan Nisota (alannisota@gmail.com)
+ * Copyright (C) 2006,2007 Genpix Electronics (genpix@genpix-electronics.com)
+ *
+ * Thanks to GENPIX for the sample code used to implement this module.
+ *
+ * This module is based off the vp7045 and vp702x modules
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "gp8psk.h"
+
+/* debug */
+static char bcm4500_firmware[] = "dvb-usb-gp8psk-02.fw";
+int dvb_usb_gp8psk_debug;
+module_param_named(debug,dvb_usb_gp8psk_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int gp8psk_get_fw_version(struct dvb_usb_device *d, u8 *fw_vers)
+{
+        return (gp8psk_usb_in_op(d, GET_FW_VERS, 0, 0, fw_vers, 6));
+}
+
+static int gp8psk_get_fpga_version(struct dvb_usb_device *d, u8 *fpga_vers)
+{
+        return (gp8psk_usb_in_op(d, GET_FPGA_VERS, 0, 0, fpga_vers, 1));
+}
+
+static void gp8psk_info(struct dvb_usb_device *d)
+{
+        u8 fpga_vers, fw_vers[6];
+
+        if (!gp8psk_get_fw_version(d, fw_vers))
+                info("FW Version = %i.%02i.%i (0x%x)  Build %4i/%02i/%02i",
+                fw_vers[2], fw_vers[1], fw_vers[0], GP8PSK_FW_VERS(fw_vers),
+                2000 + fw_vers[5], fw_vers[4], fw_vers[3]);
+        else
+                info("failed to get FW version");
+
+        if (!gp8psk_get_fpga_version(d, &fpga_vers))
+                info("FPGA Version = %i", fpga_vers);
+        else
+                info("failed to get FPGA version");
+}
+
+int gp8psk_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
+{
+        int ret = 0,try = 0;
+
+        if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
+                return ret;
+
+        while (ret >= 0 && ret != blen && try < 3) {
+                ret = usb_control_msg(d->udev,
+                        usb_rcvctrlpipe(d->udev,0),
+                        req,
+                        USB_TYPE_VENDOR | USB_DIR_IN,
+                        value,index,b,blen,
+                        2000);
+                deb_info("reading number %d (ret: %d)\n",try,ret);
+                try++;
+        }
+
+        if (ret < 0 || ret != blen) {
+                warn("usb in %d operation failed.", req);
+                ret = -EIO;
+        } else
+                ret = 0;
+
+        deb_xfer("in: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
+        debug_dump(b,blen,deb_xfer);
+
+        mutex_unlock(&d->usb_mutex);
+
+        return ret;
+}
+
+int gp8psk_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
+                             u16 index, u8 *b, int blen)
+{
+        int ret;
+
+        deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
+        debug_dump(b,blen,deb_xfer);
+
+        if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
+                return ret;
+
+        if (usb_control_msg(d->udev,
+                        usb_sndctrlpipe(d->udev,0),
+                        req,
+                        USB_TYPE_VENDOR | USB_DIR_OUT,
+                        value,index,b,blen,
+                        2000) != blen) {
+                warn("usb out operation failed.");
+                ret = -EIO;
+        } else
+                ret = 0;
+        mutex_unlock(&d->usb_mutex);
+
+        return ret;
+}
+
+static int gp8psk_load_bcm4500fw(struct dvb_usb_device *d)
+{
+        int ret;
+        const struct firmware *fw = NULL;
+        const u8 *ptr;
+        u8 *buf;
+        if ((ret = request_firmware(&fw, bcm4500_firmware,
+                                        &d->udev->dev)) != 0) {
+                err("did not find the bcm4500 firmware file. (%s) "
+                        "Please see linux/Documentation/dvb/ for more details on firmware-problems. (%d)",
+                        bcm4500_firmware,ret);
+                return ret;
+        }
+
+        ret = -EINVAL;
+
+        if (gp8psk_usb_out_op(d, LOAD_BCM4500,1,0,NULL, 0))
+                goto out_rel_fw;
+
+        info("downloading bcm4500 firmware from file '%s'",bcm4500_firmware);
+
+        ptr = fw->data;
+        buf = kmalloc(64, GFP_KERNEL | GFP_DMA);
+        if (!buf) {
+                ret = -ENOMEM;
+                goto out_rel_fw;
+        }
+
+        while (ptr[0] != 0xff) {
+                u16 buflen = ptr[0] + 4;
+                if (ptr + buflen >= fw->data + fw->size) {
+                        err("failed to load bcm4500 firmware.");
+                        goto out_free;
+                }
+                memcpy(buf, ptr, buflen);
+                if (dvb_usb_generic_write(d, buf, buflen)) {
+                        err("failed to load bcm4500 firmware.");
+                        goto out_free;
+                }
+                ptr += buflen;
+        }
+
+        ret = 0;
+
+out_free:
+        kfree(buf);
+out_rel_fw:
+        release_firmware(fw);
+
+        return ret;
+}
+
+static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 status, buf;
+        int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);
+
+        if (onoff) {
+                gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
+                if (! (status & bm8pskStarted)) {  /* started */
+                        if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
+                                gp8psk_usb_out_op(d, CW3K_INIT, 1, 0, NULL, 0);
+                        if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
+                                return -EINVAL;
+                        gp8psk_info(d);
+                }
+
+                if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
+                        if (! (status & bm8pskFW_Loaded)) /* BCM4500 firmware loaded */
+                                if(gp8psk_load_bcm4500fw(d))
+                                        return -EINVAL;
+
+                if (! (status & bmIntersilOn)) /* LNB Power */
+                        if (gp8psk_usb_in_op(d, START_INTERSIL, 1, 0,
+                                        &buf, 1))
+                                return -EINVAL;
+
+                /* Set DVB mode to 1 */
+                if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
+                        if (gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0))
+                                return -EINVAL;
+                /* Abort possible TS (if previous tune crashed) */
+                if (gp8psk_usb_out_op(d, ARM_TRANSFER, 0, 0, NULL, 0))
+                        return -EINVAL;
+        } else {
+                /* Turn off LNB power */
+                if (gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1))
+                        return -EINVAL;
+                /* Turn off 8psk power */
+                if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
+                        return -EINVAL;
+                if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
+                        gp8psk_usb_out_op(d, CW3K_INIT, 0, 0, NULL, 0);
+        }
+        return 0;
+}
+
+int gp8psk_bcm4500_reload(struct dvb_usb_device *d)
+{
+        u8 buf;
+        int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);
+        /* Turn off 8psk power */
+        if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
+                return -EINVAL;
+        /* Turn On 8psk power */
+        if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
+                return -EINVAL;
+        /* load BCM4500 firmware */
+        if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
+                if (gp8psk_load_bcm4500fw(d))
+                        return -EINVAL;
+        return 0;
+}
+
+static int gp8psk_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        return gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0);
+}
+
+static int gp8psk_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        adap->fe = gp8psk_fe_attach(adap->dev);
+        return 0;
+}
+
+static struct dvb_usb_device_properties gp8psk_properties;
+
+static int gp8psk_usb_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        int ret;
+        struct usb_device *udev = interface_to_usbdev(intf);
+        ret = dvb_usb_device_init(intf, &gp8psk_properties,
+                                  THIS_MODULE, NULL, adapter_nr);
+        if (ret == 0) {
+                info("found Genpix USB device pID = %x (hex)",
+                        le16_to_cpu(udev->descriptor.idProduct));
+        }
+        return ret;
+}
+
+static struct usb_device_id gp8psk_usb_table [] = {
+            { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_COLD) },
+            { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_WARM) },
+            { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_2) },
+            { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_1) },
+            { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_2) },
+/*          { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_CW3K) }, */
+            { 0 },
+};
+MODULE_DEVICE_TABLE(usb, gp8psk_usb_table);
+
+static struct dvb_usb_device_properties gp8psk_properties = {
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-gp8psk-01.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = gp8psk_streaming_ctrl,
+                        .frontend_attach  = gp8psk_frontend_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 8192,
+                                        }
+                                }
+                        },
+                }
+        },
+        .power_ctrl       = gp8psk_power_ctrl,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 4,
+        .devices = {
+                { .name = "Genpix 8PSK-to-USB2 Rev.1 DVB-S receiver",
+                  .cold_ids = { &gp8psk_usb_table[0], NULL },
+                  .warm_ids = { &gp8psk_usb_table[1], NULL },
+                },
+                { .name = "Genpix 8PSK-to-USB2 Rev.2 DVB-S receiver",
+                  .cold_ids = { NULL },
+                  .warm_ids = { &gp8psk_usb_table[2], NULL },
+                },
+                { .name = "Genpix SkyWalker-1 DVB-S receiver",
+                  .cold_ids = { NULL },
+                  .warm_ids = { &gp8psk_usb_table[3], NULL },
+                },
+                { .name = "Genpix SkyWalker-2 DVB-S receiver",
+                  .cold_ids = { NULL },
+                  .warm_ids = { &gp8psk_usb_table[4], NULL },
+                },
+                { NULL },
+        }
+};
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver gp8psk_usb_driver = {
+        .name           = "dvb_usb_gp8psk",
+        .probe          = gp8psk_usb_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = gp8psk_usb_table,
+};
+
+/* module stuff */
+static int __init gp8psk_usb_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&gp8psk_usb_driver))) {
+                err("usb_register failed. (%d)",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit gp8psk_usb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&gp8psk_usb_driver);
+}
+
+module_init(gp8psk_usb_module_init);
+module_exit(gp8psk_usb_module_exit);
+
+MODULE_AUTHOR("Alan Nisota <alannisota@gamil.com>");
+MODULE_DESCRIPTION("Driver for Genpix DVB-S");
+MODULE_VERSION("1.1");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/gp8psk.h b/drivers/media/dvb/dvb-usb/gp8psk.h
new file mode 100644
index 00000000000..ed32b9da484
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/gp8psk.h
@@ -0,0 +1,100 @@
+/* DVB USB compliant Linux driver for the
+ *  - GENPIX 8pks/qpsk/DCII USB2.0 DVB-S module
+ *
+ * Copyright (C) 2006 Alan Nisota (alannisota@gmail.com)
+ * Copyright (C) 2006,2007 Alan Nisota (alannisota@gmail.com)
+ *
+ * Thanks to GENPIX for the sample code used to implement this module.
+ *
+ * This module is based off the vp7045 and vp702x modules
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_GP8PSK_H_
+#define _DVB_USB_GP8PSK_H_
+
+#define DVB_USB_LOG_PREFIX "gp8psk"
+#include "dvb-usb.h"
+
+extern int dvb_usb_gp8psk_debug;
+#define deb_info(args...) dprintk(dvb_usb_gp8psk_debug,0x01,args)
+#define deb_xfer(args...) dprintk(dvb_usb_gp8psk_debug,0x02,args)
+#define deb_rc(args...)   dprintk(dvb_usb_gp8psk_debug,0x04,args)
+#define deb_fe(args...)   dprintk(dvb_usb_gp8psk_debug,0x08,args)
+
+/* Twinhan Vendor requests */
+#define TH_COMMAND_IN                     0xC0
+#define TH_COMMAND_OUT                    0xC1
+
+/* gp8psk commands */
+
+#define GET_8PSK_CONFIG                 0x80    /* in */
+#define SET_8PSK_CONFIG                 0x81
+#define I2C_WRITE                       0x83
+#define I2C_READ                        0x84
+#define ARM_TRANSFER                    0x85
+#define TUNE_8PSK                       0x86
+#define GET_SIGNAL_STRENGTH             0x87    /* in */
+#define LOAD_BCM4500                    0x88
+#define BOOT_8PSK                       0x89    /* in */
+#define START_INTERSIL                  0x8A    /* in */
+#define SET_LNB_VOLTAGE                 0x8B
+#define SET_22KHZ_TONE                  0x8C
+#define SEND_DISEQC_COMMAND             0x8D
+#define SET_DVB_MODE                    0x8E
+#define SET_DN_SWITCH                   0x8F
+#define GET_SIGNAL_LOCK                 0x90    /* in */
+#define GET_FW_VERS                     0x92
+#define GET_SERIAL_NUMBER               0x93    /* in */
+#define USE_EXTRA_VOLT                  0x94
+#define GET_FPGA_VERS                   0x95
+#define CW3K_INIT                       0x9d
+
+/* PSK_configuration bits */
+#define bm8pskStarted                   0x01
+#define bm8pskFW_Loaded                 0x02
+#define bmIntersilOn                    0x04
+#define bmDVBmode                       0x08
+#define bm22kHz                         0x10
+#define bmSEL18V                        0x20
+#define bmDCtuned                       0x40
+#define bmArmed                         0x80
+
+/* Satellite modulation modes */
+#define ADV_MOD_DVB_QPSK 0     /* DVB-S QPSK */
+#define ADV_MOD_TURBO_QPSK 1   /* Turbo QPSK */
+#define ADV_MOD_TURBO_8PSK 2   /* Turbo 8PSK (also used for Trellis 8PSK) */
+#define ADV_MOD_TURBO_16QAM 3  /* Turbo 16QAM (also used for Trellis 8PSK) */
+
+#define ADV_MOD_DCII_C_QPSK 4  /* Digicipher II Combo */
+#define ADV_MOD_DCII_I_QPSK 5  /* Digicipher II I-stream */
+#define ADV_MOD_DCII_Q_QPSK 6  /* Digicipher II Q-stream */
+#define ADV_MOD_DCII_C_OQPSK 7 /* Digicipher II offset QPSK */
+#define ADV_MOD_DSS_QPSK 8     /* DSS (DIRECTV) QPSK */
+#define ADV_MOD_DVB_BPSK 9     /* DVB-S BPSK */
+
+#define GET_USB_SPEED                     0x07
+
+#define RESET_FX2                         0x13
+
+#define FW_VERSION_READ                   0x0B
+#define VENDOR_STRING_READ                0x0C
+#define PRODUCT_STRING_READ               0x0D
+#define FW_BCD_VERSION_READ               0x14
+
+/* firmware revision id's */
+#define GP8PSK_FW_REV1                  0x020604
+#define GP8PSK_FW_REV2                  0x020704
+#define GP8PSK_FW_VERS(_fw_vers)        ((_fw_vers)[2]<<0x10 | (_fw_vers)[1]<<0x08 | (_fw_vers)[0])
+
+extern struct dvb_frontend * gp8psk_fe_attach(struct dvb_usb_device *d);
+extern int gp8psk_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen);
+extern int gp8psk_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
+                             u16 index, u8 *b, int blen);
+extern int gp8psk_bcm4500_reload(struct dvb_usb_device *d);
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/lmedm04.c b/drivers/media/dvb/dvb-usb/lmedm04.c
new file mode 100644
index 00000000000..37b146961ae
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/lmedm04.c
@@ -0,0 +1,1310 @@
+/* DVB USB compliant linux driver for
+ *
+ * DM04/QQBOX DVB-S USB BOX     LME2510C + SHARP:BS2F7HZ7395
+ *                              LME2510C + LG TDQY-P001F
+ *                              LME2510C + BS2F7HZ0194
+ *                              LME2510 + LG TDQY-P001F
+ *                              LME2510 + BS2F7HZ0194
+ *
+ * MVB7395 (LME2510C+SHARP:BS2F7HZ7395)
+ * SHARP:BS2F7HZ7395 = (STV0288+Sharp IX2505V)
+ *
+ * MV001F (LME2510+LGTDQY-P001F)
+ * LG TDQY - P001F =(TDA8263 + TDA10086H)
+ *
+ * MVB0001F (LME2510C+LGTDQT-P001F)
+ *
+ * MV0194 (LME2510+SHARP:BS2F7HZ0194)
+ * SHARP:BS2F7HZ0194 = (STV0299+IX2410)
+ *
+ * MVB0194 (LME2510C+SHARP0194)
+ *
+ * For firmware see Documentation/dvb/lmedm04.txt
+ *
+ * I2C addresses:
+ * 0xd0 - STV0288       - Demodulator
+ * 0xc0 - Sharp IX2505V - Tuner
+ * --
+ * 0x1c - TDA10086   - Demodulator
+ * 0xc0 - TDA8263    - Tuner
+ * --
+ * 0xd0 - STV0299       - Demodulator
+ * 0xc0 - IX2410        - Tuner
+ *
+ *
+ * VID = 3344  PID LME2510=1122 LME2510C=1120
+ *
+ * Copyright (C) 2010 Malcolm Priestley (tvboxspy@gmail.com)
+ * LME2510(C)(C) Leaguerme (Shenzhen) MicroElectronics Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License Version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ *
+ * Known Issues :
+ *      LME2510: Non Intel USB chipsets fail to maintain High Speed on
+ * Boot or Hot Plug.
+ *
+ * QQbox suffers from noise on LNB voltage.
+ *
+ *      LME2510: SHARP:BS2F7HZ0194(MV0194) cannot cold reset and share system
+ * with other tuners. After a cold reset streaming will not start.
+ *
+ */
+#define DVB_USB_LOG_PREFIX "LME2510(C)"
+#include <linux/usb.h>
+#include <linux/usb/input.h>
+#include <media/rc-core.h>
+
+#include "dvb-usb.h"
+#include "lmedm04.h"
+#include "tda826x.h"
+#include "tda10086.h"
+#include "stv0288.h"
+#include "ix2505v.h"
+#include "stv0299.h"
+#include "dvb-pll.h"
+#include "z0194a.h"
+
+
+
+/* debug */
+static int dvb_usb_lme2510_debug;
+#define l_dprintk(var, level, args...) do { \
+        if ((var >= level)) \
+                printk(KERN_DEBUG DVB_USB_LOG_PREFIX ": " args); \
+} while (0)
+
+#define deb_info(level, args...) l_dprintk(dvb_usb_lme2510_debug, level, args)
+#define debug_data_snipet(level, name, p) \
+         deb_info(level, name" (%02x%02x%02x%02x%02x%02x%02x%02x)", \
+                *p, *(p+1), *(p+2), *(p+3), *(p+4), \
+                        *(p+5), *(p+6), *(p+7));
+
+
+module_param_named(debug, dvb_usb_lme2510_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able))."
+                        DVB_USB_DEBUG_STATUS);
+
+static int dvb_usb_lme2510_firmware;
+module_param_named(firmware, dvb_usb_lme2510_firmware, int, 0644);
+MODULE_PARM_DESC(firmware, "set default firmware 0=Sharp7395 1=LG");
+
+static int pid_filter;
+module_param_named(pid, pid_filter, int, 0644);
+MODULE_PARM_DESC(pid, "set default 0=on 1=off");
+
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+#define TUNER_DEFAULT   0x0
+#define TUNER_LG        0x1
+#define TUNER_S7395     0x2
+#define TUNER_S0194     0x3
+
+struct lme2510_state {
+        u8 id;
+        u8 tuner_config;
+        u8 signal_lock;
+        u8 signal_level;
+        u8 signal_sn;
+        u8 time_key;
+        u8 i2c_talk_onoff;
+        u8 i2c_gate;
+        u8 i2c_tuner_gate_w;
+        u8 i2c_tuner_gate_r;
+        u8 i2c_tuner_addr;
+        u8 stream_on;
+        u8 pid_size;
+        void *buffer;
+        struct urb *lme_urb;
+        void *usb_buffer;
+
+};
+
+static int lme2510_bulk_write(struct usb_device *dev,
+                                u8 *snd, int len, u8 pipe)
+{
+        int ret, actual_l;
+
+        ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, pipe),
+                                snd, len , &actual_l, 100);
+        return ret;
+}
+
+static int lme2510_bulk_read(struct usb_device *dev,
+                                u8 *rev, int len, u8 pipe)
+{
+        int ret, actual_l;
+
+        ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, pipe),
+                                 rev, len , &actual_l, 200);
+        return ret;
+}
+
+static int lme2510_usb_talk(struct dvb_usb_device *d,
+                u8 *wbuf, int wlen, u8 *rbuf, int rlen)
+{
+        struct lme2510_state *st = d->priv;
+        u8 *buff;
+        int ret = 0;
+
+        if (st->usb_buffer == NULL) {
+                st->usb_buffer = kmalloc(512, GFP_KERNEL);
+                if (st->usb_buffer == NULL) {
+                        info("MEM Error no memory");
+                        return -ENOMEM;
+                }
+        }
+        buff = st->usb_buffer;
+
+        ret = mutex_lock_interruptible(&d->usb_mutex);
+
+        if (ret < 0)
+                return -EAGAIN;
+
+        /* the read/write capped at 512 */
+        memcpy(buff, wbuf, (wlen > 512) ? 512 : wlen);
+
+        ret |= usb_clear_halt(d->udev, usb_sndbulkpipe(d->udev, 0x01));
+
+        ret |= lme2510_bulk_write(d->udev, buff, wlen , 0x01);
+
+        msleep(10);
+
+        ret |= usb_clear_halt(d->udev, usb_rcvbulkpipe(d->udev, 0x01));
+
+        ret |= lme2510_bulk_read(d->udev, buff, (rlen > 512) ?
+                        512 : rlen , 0x01);
+
+        if (rlen > 0)
+                memcpy(rbuf, buff, rlen);
+
+        mutex_unlock(&d->usb_mutex);
+
+        return (ret < 0) ? -ENODEV : 0;
+}
+
+static int lme2510_stream_restart(struct dvb_usb_device *d)
+{
+        static u8 stream_on[] = LME_ST_ON_W;
+        int ret;
+        u8 rbuff[10];
+        /*Restart Stream Command*/
+        ret = lme2510_usb_talk(d, stream_on, sizeof(stream_on),
+                        rbuff, sizeof(rbuff));
+        return ret;
+}
+
+static int lme2510_enable_pid(struct dvb_usb_device *d, u8 index, u16 pid_out)
+{
+        struct lme2510_state *st = d->priv;
+        static u8 pid_buff[] = LME_ZERO_PID;
+        static u8 rbuf[1];
+        u8 pid_no = index * 2;
+        u8 pid_len = pid_no + 2;
+        int ret = 0;
+        deb_info(1, "PID Setting Pid %04x", pid_out);
+
+        if (st->pid_size == 0)
+                ret |= lme2510_stream_restart(d);
+
+        pid_buff[2] = pid_no;
+        pid_buff[3] = (u8)pid_out & 0xff;
+        pid_buff[4] = pid_no + 1;
+        pid_buff[5] = (u8)(pid_out >> 8);
+
+        if (pid_len > st->pid_size)
+                st->pid_size = pid_len;
+        pid_buff[7] = 0x80 + st->pid_size;
+
+        ret |= lme2510_usb_talk(d, pid_buff ,
+                sizeof(pid_buff) , rbuf, sizeof(rbuf));
+
+        if (st->stream_on)
+                ret |= lme2510_stream_restart(d);
+
+        return ret;
+}
+
+static void lme2510_int_response(struct urb *lme_urb)
+{
+        struct dvb_usb_adapter *adap = lme_urb->context;
+        struct lme2510_state *st = adap->dev->priv;
+        static u8 *ibuf, *rbuf;
+        int i = 0, offset;
+        u32 key;
+
+        switch (lme_urb->status) {
+        case 0:
+        case -ETIMEDOUT:
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                return;
+        default:
+                info("Error %x", lme_urb->status);
+                break;
+        }
+
+        rbuf = (u8 *) lme_urb->transfer_buffer;
+
+        offset = ((lme_urb->actual_length/8) > 4)
+                        ? 4 : (lme_urb->actual_length/8) ;
+
+        for (i = 0; i < offset; ++i) {
+                ibuf = (u8 *)&rbuf[i*8];
+                deb_info(5, "INT O/S C =%02x C/O=%02x Type =%02x%02x",
+                offset, i, ibuf[0], ibuf[1]);
+
+                switch (ibuf[0]) {
+                case 0xaa:
+                        debug_data_snipet(1, "INT Remote data snipet", ibuf);
+                        if ((ibuf[4] + ibuf[5]) == 0xff) {
+                                key = ibuf[5];
+                                key += (ibuf[3] > 0)
+                                        ? (ibuf[3] ^ 0xff) << 8 : 0;
+                                key += (ibuf[2] ^ 0xff) << 16;
+                                deb_info(1, "INT Key =%08x", key);
+                                if (adap->dev->rc_dev != NULL)
+                                        rc_keydown(adap->dev->rc_dev, key, 0);
+                        }
+                        break;
+                case 0xbb:
+                        switch (st->tuner_config) {
+                        case TUNER_LG:
+                                if (ibuf[2] > 0)
+                                        st->signal_lock = ibuf[2];
+                                st->signal_level = ibuf[4];
+                                st->signal_sn = ibuf[3];
+                                st->time_key = ibuf[7];
+                                break;
+                        case TUNER_S7395:
+                        case TUNER_S0194:
+                                /* Tweak for earlier firmware*/
+                                if (ibuf[1] == 0x03) {
+                                        if (ibuf[2] > 1)
+                                                st->signal_lock = ibuf[2];
+                                        st->signal_level = ibuf[3];
+                                        st->signal_sn = ibuf[4];
+                                } else {
+                                        st->signal_level = ibuf[4];
+                                        st->signal_sn = ibuf[5];
+                                        st->signal_lock =
+                                                (st->signal_lock & 0xf7) +
+                                                ((ibuf[2] & 0x01) << 0x03);
+                                }
+                                break;
+                        default:
+                                break;
+                        }
+                        debug_data_snipet(5, "INT Remote data snipet in", ibuf);
+                break;
+                case 0xcc:
+                        debug_data_snipet(1, "INT Control data snipet", ibuf);
+                        break;
+                default:
+                        debug_data_snipet(1, "INT Unknown data snipet", ibuf);
+                break;
+                }
+        }
+        usb_submit_urb(lme_urb, GFP_ATOMIC);
+}
+
+static int lme2510_int_read(struct dvb_usb_adapter *adap)
+{
+        struct lme2510_state *lme_int = adap->dev->priv;
+
+        lme_int->lme_urb = usb_alloc_urb(0, GFP_ATOMIC);
+
+        if (lme_int->lme_urb == NULL)
+                        return -ENOMEM;
+
+        lme_int->buffer = usb_alloc_coherent(adap->dev->udev, 5000, GFP_ATOMIC,
+                                        &lme_int->lme_urb->transfer_dma);
+
+        if (lme_int->buffer == NULL)
+                        return -ENOMEM;
+
+        usb_fill_int_urb(lme_int->lme_urb,
+                                adap->dev->udev,
+                                usb_rcvintpipe(adap->dev->udev, 0xa),
+                                lme_int->buffer,
+                                4096,
+                                lme2510_int_response,
+                                adap,
+                                11);
+
+        lme_int->lme_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+        usb_submit_urb(lme_int->lme_urb, GFP_ATOMIC);
+        info("INT Interrupt Service Started");
+
+        return 0;
+}
+
+static int lme2510_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        struct lme2510_state *st = adap->dev->priv;
+        static u8 clear_pid_reg[] = LME_CLEAR_PID;
+        static u8 rbuf[1];
+        int ret;
+
+        deb_info(1, "PID Clearing Filter");
+
+        ret = mutex_lock_interruptible(&adap->dev->i2c_mutex);
+        if (ret < 0)
+                return -EAGAIN;
+
+        if (!onoff)
+                ret |= lme2510_usb_talk(adap->dev, clear_pid_reg,
+                        sizeof(clear_pid_reg), rbuf, sizeof(rbuf));
+
+        st->pid_size = 0;
+
+        mutex_unlock(&adap->dev->i2c_mutex);
+
+        return 0;
+}
+
+static int lme2510_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
+        int onoff)
+{
+        int ret = 0;
+
+        deb_info(3, "%s PID=%04x Index=%04x onoff=%02x", __func__,
+                pid, index, onoff);
+
+        if (onoff)
+                if (!pid_filter) {
+                        ret = mutex_lock_interruptible(&adap->dev->i2c_mutex);
+                        if (ret < 0)
+                                return -EAGAIN;
+                        ret |= lme2510_enable_pid(adap->dev, index, pid);
+                        mutex_unlock(&adap->dev->i2c_mutex);
+        }
+
+
+        return ret;
+}
+
+
+static int lme2510_return_status(struct usb_device *dev)
+{
+        int ret = 0;
+        u8 *data;
+
+        data = kzalloc(10, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        ret |= usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                        0x06, 0x80, 0x0302, 0x00, data, 0x0006, 200);
+        info("Firmware Status: %x (%x)", ret , data[2]);
+
+        ret = (ret < 0) ? -ENODEV : data[2];
+        kfree(data);
+        return ret;
+}
+
+static int lme2510_msg(struct dvb_usb_device *d,
+                u8 *wbuf, int wlen, u8 *rbuf, int rlen)
+{
+        int ret = 0;
+        struct lme2510_state *st = d->priv;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                        return -EAGAIN;
+
+        if (st->i2c_talk_onoff == 1) {
+
+                ret = lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
+
+                switch (st->tuner_config) {
+                case TUNER_LG:
+                        if (wbuf[2] == 0x1c) {
+                                if (wbuf[3] == 0x0e) {
+                                        st->signal_lock = rbuf[1];
+                                        if ((st->stream_on & 1) &&
+                                                (st->signal_lock & 0x10)) {
+                                                lme2510_stream_restart(d);
+                                                st->i2c_talk_onoff = 0;
+                                        }
+                                        msleep(80);
+                                }
+                        }
+                        break;
+                case TUNER_S7395:
+                        if (wbuf[2] == 0xd0) {
+                                if (wbuf[3] == 0x24) {
+                                        st->signal_lock = rbuf[1];
+                                        if ((st->stream_on & 1) &&
+                                                (st->signal_lock & 0x8)) {
+                                                lme2510_stream_restart(d);
+                                                st->i2c_talk_onoff = 0;
+                                        }
+                                }
+                                if ((wbuf[3] != 0x6) & (wbuf[3] != 0x5))
+                                        msleep(5);
+                        }
+                        break;
+                case TUNER_S0194:
+                        if (wbuf[2] == 0xd0) {
+                                if (wbuf[3] == 0x1b) {
+                                        st->signal_lock = rbuf[1];
+                                        if ((st->stream_on & 1) &&
+                                                (st->signal_lock & 0x8)) {
+                                                lme2510_stream_restart(d);
+                                                st->i2c_talk_onoff = 0;
+                                        }
+                                }
+                        }
+                        break;
+                default:
+                        break;
+                }
+        } else {
+                switch (st->tuner_config) {
+                case TUNER_LG:
+                        switch (wbuf[3]) {
+                        case 0x0e:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = st->signal_lock;
+                                break;
+                        case 0x43:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = st->signal_level;
+                                break;
+                        case 0x1c:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = st->signal_sn;
+                                break;
+                        case 0x15:
+                        case 0x16:
+                        case 0x17:
+                        case 0x18:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = 0x00;
+                                break;
+                        default:
+                                lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
+                                st->i2c_talk_onoff = 1;
+                                break;
+                        }
+                        break;
+                case TUNER_S7395:
+                        switch (wbuf[3]) {
+                        case 0x10:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = (st->signal_level & 0x80)
+                                                ? 0 : (st->signal_level * 2);
+                                break;
+                        case 0x2d:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = st->signal_sn;
+                                break;
+                        case 0x24:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = st->signal_lock;
+                                break;
+                        case 0x2e:
+                        case 0x26:
+                        case 0x27:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = 0x00;
+                                break;
+                        default:
+                                lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
+                                st->i2c_talk_onoff = 1;
+                                break;
+                        }
+                        break;
+                case TUNER_S0194:
+                        switch (wbuf[3]) {
+                        case 0x18:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = (st->signal_level & 0x80)
+                                                ? 0 : (st->signal_level * 2);
+                                break;
+                        case 0x24:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = st->signal_sn;
+                                break;
+                        case 0x1b:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = st->signal_lock;
+                                break;
+                        case 0x19:
+                        case 0x25:
+                        case 0x1e:
+                        case 0x1d:
+                                rbuf[0] = 0x55;
+                                rbuf[1] = 0x00;
+                                break;
+                        default:
+                                lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
+                                st->i2c_talk_onoff = 1;
+                                break;
+                        }
+                        break;
+                default:
+                        break;
+                }
+
+                deb_info(4, "I2C From Interrupt Message out(%02x) in(%02x)",
+                                wbuf[3], rbuf[1]);
+
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+
+        return ret;
+}
+
+
+static int lme2510_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                                 int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        struct lme2510_state *st = d->priv;
+        static u8 obuf[64], ibuf[512];
+        int i, read, read_o;
+        u16 len;
+        u8 gate = st->i2c_gate;
+
+        if (gate == 0)
+                gate = 5;
+
+        if (num > 2)
+                warn("more than 2 i2c messages"
+                        "at a time is not handled yet.  TODO.");
+
+        for (i = 0; i < num; i++) {
+                read_o = 1 & (msg[i].flags & I2C_M_RD);
+                read = i+1 < num && (msg[i+1].flags & I2C_M_RD);
+                read |= read_o;
+                gate = (msg[i].addr == st->i2c_tuner_addr)
+                        ? (read)        ? st->i2c_tuner_gate_r
+                                        : st->i2c_tuner_gate_w
+                        : st->i2c_gate;
+                obuf[0] = gate | (read << 7);
+
+                if (gate == 5)
+                        obuf[1] = (read) ? 2 : msg[i].len + 1;
+                else
+                        obuf[1] = msg[i].len + read + 1;
+
+                obuf[2] = msg[i].addr;
+                if (read) {
+                        if (read_o)
+                                len = 3;
+                        else {
+                                memcpy(&obuf[3], msg[i].buf, msg[i].len);
+                                obuf[msg[i].len+3] = msg[i+1].len;
+                                len = msg[i].len+4;
+                        }
+                } else {
+                        memcpy(&obuf[3], msg[i].buf, msg[i].len);
+                        len = msg[i].len+3;
+                }
+
+                if (lme2510_msg(d, obuf, len, ibuf, 512) < 0) {
+                        deb_info(1, "i2c transfer failed.");
+                        return -EAGAIN;
+                }
+
+                if (read) {
+                        if (read_o)
+                                memcpy(msg[i].buf, &ibuf[1], msg[i].len);
+                        else {
+                                memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
+                                i++;
+                        }
+                }
+        }
+        return i;
+}
+
+static u32 lme2510_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm lme2510_i2c_algo = {
+        .master_xfer   = lme2510_i2c_xfer,
+        .functionality = lme2510_i2c_func,
+};
+
+/* Callbacks for DVB USB */
+static int lme2510_identify_state(struct usb_device *udev,
+                struct dvb_usb_device_properties *props,
+                struct dvb_usb_device_description **desc,
+                int *cold)
+{
+        *cold = 0;
+        return 0;
+}
+
+static int lme2510_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        struct lme2510_state *st = adap->dev->priv;
+        static u8 clear_reg_3[] = LME_CLEAR_PID;
+        static u8 rbuf[1];
+        int ret = 0, rlen = sizeof(rbuf);
+
+        deb_info(1, "STM  (%02x)", onoff);
+
+        /* Streaming is started by FE_HAS_LOCK */
+        if (onoff == 1)
+                st->stream_on = 1;
+        else {
+                deb_info(1, "STM Steam Off");
+                /* mutex is here only to avoid collision with I2C */
+                if (mutex_lock_interruptible(&adap->dev->i2c_mutex) < 0)
+                        return -EAGAIN;
+
+                ret = lme2510_usb_talk(adap->dev, clear_reg_3,
+                                sizeof(clear_reg_3), rbuf, rlen);
+                st->stream_on = 0;
+                st->i2c_talk_onoff = 1;
+
+                mutex_unlock(&adap->dev->i2c_mutex);
+        }
+
+        return (ret < 0) ? -ENODEV : 0;
+}
+
+static u8 check_sum(u8 *p, u8 len)
+{
+        u8 sum = 0;
+        while (len--)
+                sum += *p++;
+        return sum;
+}
+
+static int lme2510_download_firmware(struct usb_device *dev,
+                                        const struct firmware *fw)
+{
+        int ret = 0;
+        u8 *data;
+        u16 j, wlen, len_in, start, end;
+        u8 packet_size, dlen, i;
+        u8 *fw_data;
+
+        packet_size = 0x31;
+        len_in = 1;
+
+        data = kzalloc(512, GFP_KERNEL);
+        if (!data) {
+                info("FRM Could not start Firmware Download (Buffer allocation failed)");
+                return -ENOMEM;
+        }
+
+        info("FRM Starting Firmware Download");
+
+        for (i = 1; i < 3; i++) {
+                start = (i == 1) ? 0 : 512;
+                end = (i == 1) ? 512 : fw->size;
+                for (j = start; j < end; j += (packet_size+1)) {
+                        fw_data = (u8 *)(fw->data + j);
+                        if ((end - j) > packet_size) {
+                                data[0] = i;
+                                dlen = packet_size;
+                        } else {
+                                data[0] = i | 0x80;
+                                dlen = (u8)(end - j)-1;
+                        }
+                        data[1] = dlen;
+                        memcpy(&data[2], fw_data, dlen+1);
+                        wlen = (u8) dlen + 4;
+                        data[wlen-1] = check_sum(fw_data, dlen+1);
+                        deb_info(1, "Data S=%02x:E=%02x CS= %02x", data[3],
+                                data[dlen+2], data[dlen+3]);
+                        ret |= lme2510_bulk_write(dev, data,  wlen, 1);
+                        ret |= lme2510_bulk_read(dev, data, len_in , 1);
+                        ret |= (data[0] == 0x88) ? 0 : -1;
+                }
+        }
+
+        usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                        0x06, 0x80, 0x0200, 0x00, data, 0x0109, 1000);
+
+
+        data[0] = 0x8a;
+        len_in = 1;
+        msleep(2000);
+        ret |= lme2510_bulk_write(dev, data , len_in, 1); /*Resetting*/
+        ret |= lme2510_bulk_read(dev, data, len_in, 1);
+        msleep(400);
+
+        if (ret < 0)
+                info("FRM Firmware Download Failed (%04x)" , ret);
+        else
+                info("FRM Firmware Download Completed - Resetting Device");
+
+        kfree(data);
+        return (ret < 0) ? -ENODEV : 0;
+}
+
+static void lme_coldreset(struct usb_device *dev)
+{
+        int ret = 0, len_in;
+        u8 data[512] = {0};
+
+        data[0] = 0x0a;
+        len_in = 1;
+        info("FRM Firmware Cold Reset");
+        ret |= lme2510_bulk_write(dev, data , len_in, 1); /*Cold Resetting*/
+        ret |= lme2510_bulk_read(dev, data, len_in, 1);
+
+        return;
+}
+
+static int lme_firmware_switch(struct usb_device *udev, int cold)
+{
+        const struct firmware *fw = NULL;
+        const char fw_c_s7395[] = "dvb-usb-lme2510c-s7395.fw";
+        const char fw_c_lg[] = "dvb-usb-lme2510c-lg.fw";
+        const char fw_c_s0194[] = "dvb-usb-lme2510c-s0194.fw";
+        const char fw_lg[] = "dvb-usb-lme2510-lg.fw";
+        const char fw_s0194[] = "dvb-usb-lme2510-s0194.fw";
+        const char *fw_lme;
+        int ret, cold_fw;
+
+        cold = (cold > 0) ? (cold & 1) : 0;
+
+        cold_fw = !cold;
+
+        if (le16_to_cpu(udev->descriptor.idProduct) == 0x1122) {
+                switch (dvb_usb_lme2510_firmware) {
+                default:
+                        dvb_usb_lme2510_firmware = TUNER_S0194;
+                case TUNER_S0194:
+                        fw_lme = fw_s0194;
+                        ret = request_firmware(&fw, fw_lme, &udev->dev);
+                        if (ret == 0) {
+                                cold = 0;
+                                break;
+                        }
+                        dvb_usb_lme2510_firmware = TUNER_LG;
+                case TUNER_LG:
+                        fw_lme = fw_lg;
+                        ret = request_firmware(&fw, fw_lme, &udev->dev);
+                        if (ret == 0)
+                                break;
+                        info("FRM No Firmware Found - please install");
+                        dvb_usb_lme2510_firmware = TUNER_DEFAULT;
+                        cold = 0;
+                        cold_fw = 0;
+                        break;
+                }
+        } else {
+                switch (dvb_usb_lme2510_firmware) {
+                default:
+                        dvb_usb_lme2510_firmware = TUNER_S7395;
+                case TUNER_S7395:
+                        fw_lme = fw_c_s7395;
+                        ret = request_firmware(&fw, fw_lme, &udev->dev);
+                        if (ret == 0) {
+                                cold = 0;
+                                break;
+                        }
+                        dvb_usb_lme2510_firmware = TUNER_LG;
+                case TUNER_LG:
+                        fw_lme = fw_c_lg;
+                        ret = request_firmware(&fw, fw_lme, &udev->dev);
+                        if (ret == 0)
+                                break;
+                        dvb_usb_lme2510_firmware = TUNER_S0194;
+                case TUNER_S0194:
+                        fw_lme = fw_c_s0194;
+                        ret = request_firmware(&fw, fw_lme, &udev->dev);
+                        if (ret == 0)
+                                break;
+                        info("FRM No Firmware Found - please install");
+                        dvb_usb_lme2510_firmware = TUNER_DEFAULT;
+                        cold = 0;
+                        cold_fw = 0;
+                        break;
+                }
+        }
+
+        if (cold_fw) {
+                info("FRM Loading %s file", fw_lme);
+                ret = lme2510_download_firmware(udev, fw);
+        }
+
+        release_firmware(fw);
+
+        if (cold) {
+                info("FRM Changing to %s firmware", fw_lme);
+                lme_coldreset(udev);
+                return -ENODEV;
+        }
+
+        return ret;
+}
+
+static int lme2510_kill_urb(struct usb_data_stream *stream)
+{
+        int i;
+
+        for (i = 0; i < stream->urbs_submitted; i++) {
+                deb_info(3, "killing URB no. %d.", i);
+                /* stop the URB */
+                usb_kill_urb(stream->urb_list[i]);
+        }
+        stream->urbs_submitted = 0;
+
+        return 0;
+}
+
+static struct tda10086_config tda10086_config = {
+        .demod_address = 0x1c,
+        .invert = 0,
+        .diseqc_tone = 1,
+        .xtal_freq = TDA10086_XTAL_16M,
+};
+
+static struct stv0288_config lme_config = {
+        .demod_address = 0xd0,
+        .min_delay_ms = 15,
+        .inittab = s7395_inittab,
+};
+
+static struct ix2505v_config lme_tuner = {
+        .tuner_address = 0xc0,
+        .min_delay_ms = 100,
+        .tuner_gain = 0x0,
+        .tuner_chargepump = 0x3,
+};
+
+static struct stv0299_config sharp_z0194_config = {
+        .demod_address = 0xd0,
+        .inittab = sharp_z0194a_inittab,
+        .mclk = 88000000UL,
+        .invert = 0,
+        .skip_reinit = 0,
+        .lock_output = STV0299_LOCKOUTPUT_1,
+        .volt13_op0_op1 = STV0299_VOLT13_OP1,
+        .min_delay_ms = 100,
+        .set_symbol_rate = sharp_z0194a_set_symbol_rate,
+};
+
+static int dm04_lme2510_set_voltage(struct dvb_frontend *fe,
+                                        fe_sec_voltage_t voltage)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        static u8 voltage_low[] = LME_VOLTAGE_L;
+        static u8 voltage_high[] = LME_VOLTAGE_H;
+        static u8 rbuf[1];
+        int ret = 0, len = 3, rlen = 1;
+
+        if (mutex_lock_interruptible(&adap->dev->i2c_mutex) < 0)
+                        return -EAGAIN;
+
+        switch (voltage) {
+        case SEC_VOLTAGE_18:
+                ret |= lme2510_usb_talk(adap->dev,
+                        voltage_high, len, rbuf, rlen);
+                break;
+
+        case SEC_VOLTAGE_OFF:
+        case SEC_VOLTAGE_13:
+        default:
+                ret |= lme2510_usb_talk(adap->dev,
+                                voltage_low, len, rbuf, rlen);
+                break;
+        }
+
+        mutex_unlock(&adap->dev->i2c_mutex);
+
+        return (ret < 0) ? -ENODEV : 0;
+}
+
+static int lme_name(struct dvb_usb_adapter *adap)
+{
+        struct lme2510_state *st = adap->dev->priv;
+        const char *desc = adap->dev->desc->name;
+        char *fe_name[] = {"", " LG TDQY-P001F", " SHARP:BS2F7HZ7395",
+                                " SHARP:BS2F7HZ0194"};
+        char *name = adap->fe->ops.info.name;
+
+        strlcpy(name, desc, 128);
+        strlcat(name, fe_name[st->tuner_config], 128);
+
+        return 0;
+}
+
+static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct lme2510_state *st = adap->dev->priv;
+
+        int ret = 0;
+
+        st->i2c_talk_onoff = 1;
+
+        st->i2c_gate = 4;
+        adap->fe = dvb_attach(tda10086_attach, &tda10086_config,
+                &adap->dev->i2c_adap);
+
+        if (adap->fe) {
+                info("TUN Found Frontend TDA10086");
+                st->i2c_tuner_gate_w = 4;
+                st->i2c_tuner_gate_r = 4;
+                st->i2c_tuner_addr = 0xc0;
+                st->tuner_config = TUNER_LG;
+                if (dvb_usb_lme2510_firmware != TUNER_LG) {
+                        dvb_usb_lme2510_firmware = TUNER_LG;
+                        ret = lme_firmware_switch(adap->dev->udev, 1);
+                }
+                goto end;
+        }
+
+        st->i2c_gate = 4;
+        adap->fe = dvb_attach(stv0299_attach, &sharp_z0194_config,
+                        &adap->dev->i2c_adap);
+        if (adap->fe) {
+                info("FE Found Stv0299");
+                st->i2c_tuner_gate_w = 4;
+                st->i2c_tuner_gate_r = 5;
+                st->i2c_tuner_addr = 0xc0;
+                st->tuner_config = TUNER_S0194;
+                if (dvb_usb_lme2510_firmware != TUNER_S0194) {
+                        dvb_usb_lme2510_firmware = TUNER_S0194;
+                        ret = lme_firmware_switch(adap->dev->udev, 1);
+                }
+                goto end;
+        }
+
+        st->i2c_gate = 5;
+        adap->fe = dvb_attach(stv0288_attach, &lme_config,
+                        &adap->dev->i2c_adap);
+        if (adap->fe) {
+                info("FE Found Stv0288");
+                st->i2c_tuner_gate_w = 4;
+                st->i2c_tuner_gate_r = 5;
+                st->i2c_tuner_addr = 0xc0;
+                st->tuner_config = TUNER_S7395;
+                if (dvb_usb_lme2510_firmware != TUNER_S7395) {
+                        dvb_usb_lme2510_firmware = TUNER_S7395;
+                        ret = lme_firmware_switch(adap->dev->udev, 1);
+                }
+        } else {
+                info("DM04 Not Supported");
+                return -ENODEV;
+        }
+
+
+end:    if (ret) {
+                if (adap->fe) {
+                        dvb_frontend_detach(adap->fe);
+                        adap->fe = NULL;
+                }
+                adap->dev->props.rc.core.rc_codes = NULL;
+                return -ENODEV;
+        }
+
+        adap->fe->ops.set_voltage = dm04_lme2510_set_voltage;
+        ret = lme_name(adap);
+        return ret;
+}
+
+static int dm04_lme2510_tuner(struct dvb_usb_adapter *adap)
+{
+        struct lme2510_state *st = adap->dev->priv;
+        char *tun_msg[] = {"", "TDA8263", "IX2505V", "DVB_PLL_OPERA"};
+        int ret = 0;
+
+        switch (st->tuner_config) {
+        case TUNER_LG:
+                if (dvb_attach(tda826x_attach, adap->fe, 0xc0,
+                        &adap->dev->i2c_adap, 1))
+                        ret = st->tuner_config;
+                break;
+        case TUNER_S7395:
+                if (dvb_attach(ix2505v_attach , adap->fe, &lme_tuner,
+                        &adap->dev->i2c_adap))
+                        ret = st->tuner_config;
+                break;
+        case TUNER_S0194:
+                if (dvb_attach(dvb_pll_attach , adap->fe, 0xc0,
+                        &adap->dev->i2c_adap, DVB_PLL_OPERA1))
+                        ret = st->tuner_config;
+                break;
+        default:
+                break;
+        }
+
+        if (ret)
+                info("TUN Found %s tuner", tun_msg[ret]);
+        else {
+                info("TUN No tuner found --- reseting device");
+                lme_coldreset(adap->dev->udev);
+                return -ENODEV;
+        }
+
+        /* Start the Interrupt*/
+        ret = lme2510_int_read(adap);
+        if (ret < 0) {
+                info("INT Unable to start Interrupt Service");
+                return -ENODEV;
+        }
+
+        return ret;
+}
+
+static int lme2510_powerup(struct dvb_usb_device *d, int onoff)
+{
+        struct lme2510_state *st = d->priv;
+        static u8 lnb_on[] = LNB_ON;
+        static u8 lnb_off[] = LNB_OFF;
+        static u8 rbuf[1];
+        int ret, len = 3, rlen = 1;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        if (onoff)
+                ret = lme2510_usb_talk(d, lnb_on, len, rbuf, rlen);
+        else
+                ret = lme2510_usb_talk(d, lnb_off, len, rbuf, rlen);
+
+        st->i2c_talk_onoff = 1;
+
+        mutex_unlock(&d->i2c_mutex);
+
+        return ret;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties lme2510_properties;
+static struct dvb_usb_device_properties lme2510c_properties;
+
+static int lme2510_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+        int ret = 0;
+
+        usb_reset_configuration(udev);
+
+        usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 1);
+
+        if (udev->speed != USB_SPEED_HIGH) {
+                ret = usb_reset_device(udev);
+                info("DEV Failed to connect in HIGH SPEED mode");
+                return -ENODEV;
+        }
+
+        if (lme2510_return_status(udev) == 0x44) {
+                lme_firmware_switch(udev, 0);
+                return -ENODEV;
+        }
+
+        if (0 == dvb_usb_device_init(intf, &lme2510_properties,
+                                     THIS_MODULE, NULL, adapter_nr)) {
+                info("DEV registering device driver");
+                return 0;
+        }
+        if (0 == dvb_usb_device_init(intf, &lme2510c_properties,
+                                     THIS_MODULE, NULL, adapter_nr)) {
+                info("DEV registering device driver");
+                return 0;
+        }
+
+        info("DEV lme2510 Error");
+        return -ENODEV;
+
+}
+
+static struct usb_device_id lme2510_table[] = {
+        { USB_DEVICE(0x3344, 0x1122) },  /* LME2510 */
+        { USB_DEVICE(0x3344, 0x1120) },  /* LME2510C */
+        {}              /* Terminating entry */
+};
+
+MODULE_DEVICE_TABLE(usb, lme2510_table);
+
+static struct dvb_usb_device_properties lme2510_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .size_of_priv = sizeof(struct lme2510_state),
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER|
+                                DVB_USB_ADAP_NEED_PID_FILTERING|
+                                DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .streaming_ctrl   = lme2510_streaming_ctrl,
+                        .pid_filter_count = 15,
+                        .pid_filter = lme2510_pid_filter,
+                        .pid_filter_ctrl  = lme2510_pid_filter_ctrl,
+                        .frontend_attach  = dm04_lme2510_frontend_attach,
+                        .tuner_attach = dm04_lme2510_tuner,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 10,
+                                .endpoint = 0x06,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+
+                                        }
+                                }
+                        }
+                }
+        },
+        .rc.core = {
+                .protocol       = RC_TYPE_NEC,
+                .module_name    = "LME2510 Remote Control",
+                .allowed_protos = RC_TYPE_NEC,
+                .rc_codes       = RC_MAP_LME2510,
+        },
+        .power_ctrl       = lme2510_powerup,
+        .identify_state   = lme2510_identify_state,
+        .i2c_algo         = &lme2510_i2c_algo,
+        .generic_bulk_ctrl_endpoint = 0,
+        .num_device_descs = 1,
+        .devices = {
+                {   "DM04_LME2510_DVB-S",
+                        { &lme2510_table[0], NULL },
+                        },
+
+        }
+};
+
+static struct dvb_usb_device_properties lme2510c_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .size_of_priv = sizeof(struct lme2510_state),
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER|
+                                DVB_USB_ADAP_NEED_PID_FILTERING|
+                                DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .streaming_ctrl   = lme2510_streaming_ctrl,
+                        .pid_filter_count = 15,
+                        .pid_filter = lme2510_pid_filter,
+                        .pid_filter_ctrl  = lme2510_pid_filter_ctrl,
+                        .frontend_attach  = dm04_lme2510_frontend_attach,
+                        .tuner_attach = dm04_lme2510_tuner,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 10,
+                                .endpoint = 0x8,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+
+                                        }
+                                }
+                        }
+                }
+        },
+        .rc.core = {
+                .protocol       = RC_TYPE_NEC,
+                .module_name    = "LME2510 Remote Control",
+                .allowed_protos = RC_TYPE_NEC,
+                .rc_codes       = RC_MAP_LME2510,
+        },
+        .power_ctrl       = lme2510_powerup,
+        .identify_state   = lme2510_identify_state,
+        .i2c_algo         = &lme2510_i2c_algo,
+        .generic_bulk_ctrl_endpoint = 0,
+        .num_device_descs = 1,
+        .devices = {
+                {   "DM04_LME2510C_DVB-S",
+                        { &lme2510_table[1], NULL },
+                        },
+        }
+};
+
+static void *lme2510_exit_int(struct dvb_usb_device *d)
+{
+        struct lme2510_state *st = d->priv;
+        struct dvb_usb_adapter *adap = &d->adapter[0];
+        void *buffer = NULL;
+
+        if (adap != NULL) {
+                lme2510_kill_urb(&adap->stream);
+                adap->feedcount = 0;
+        }
+
+        if (st->usb_buffer != NULL) {
+                st->i2c_talk_onoff = 1;
+                st->signal_lock = 0;
+                st->signal_level = 0;
+                st->signal_sn = 0;
+                buffer = st->usb_buffer;
+        }
+
+        if (st->lme_urb != NULL) {
+                usb_kill_urb(st->lme_urb);
+                usb_free_coherent(d->udev, 5000, st->buffer,
+                                  st->lme_urb->transfer_dma);
+                info("Interrupt Service Stopped");
+        }
+
+        return buffer;
+}
+
+static void lme2510_exit(struct usb_interface *intf)
+{
+        struct dvb_usb_device *d = usb_get_intfdata(intf);
+        void *usb_buffer;
+
+        if (d != NULL) {
+                usb_buffer = lme2510_exit_int(d);
+                dvb_usb_device_exit(intf);
+                if (usb_buffer != NULL)
+                        kfree(usb_buffer);
+        }
+}
+
+static struct usb_driver lme2510_driver = {
+        .name           = "LME2510C_DVB-S",
+        .probe          = lme2510_probe,
+        .disconnect     = lme2510_exit,
+        .id_table       = lme2510_table,
+};
+
+/* module stuff */
+static int __init lme2510_module_init(void)
+{
+        int result = usb_register(&lme2510_driver);
+        if (result) {
+                err("usb_register failed. Error number %d", result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit lme2510_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&lme2510_driver);
+}
+
+module_init(lme2510_module_init);
+module_exit(lme2510_module_exit);
+
+MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
+MODULE_DESCRIPTION("LME2510(C) DVB-S USB2.0");
+MODULE_VERSION("1.88");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/lmedm04.h b/drivers/media/dvb/dvb-usb/lmedm04.h
new file mode 100644
index 00000000000..ab21e2ef53f
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/lmedm04.h
@@ -0,0 +1,174 @@
+/* DVB USB compliant linux driver for
+ *
+ * DM04/QQBOX DVB-S USB BOX     LME2510C + SHARP:BS2F7HZ7395
+ *                              LME2510C + LG TDQY-P001F
+ *                              LME2510 + LG TDQY-P001F
+ *
+ * MVB7395 (LME2510C+SHARP:BS2F7HZ7395)
+ * SHARP:BS2F7HZ7395 = (STV0288+Sharp IX2505V)
+ *
+ * MVB001F (LME2510+LGTDQT-P001F)
+ * LG TDQY - P001F =(TDA8263 + TDA10086H)
+ *
+ * MVB0001F (LME2510C+LGTDQT-P001F)
+ *
+ * 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,  version 2.
+ * *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_LME2510_H_
+#define _DVB_USB_LME2510_H_
+
+/* Streamer &  PID
+ *
+ * Note:        These commands do not actually stop the streaming
+ *              but form some kind of packet filtering/stream count
+ *              or tuning related functions.
+ *  06 XX
+ *  offset 1 = 00 Enable Streaming
+ *
+ *
+ *  PID
+ *  03 XX XX  ----> reg number ---> setting....20 XX
+ *  offset 1 = length
+ *  offset 2 = start of data
+ *  end byte -1 = 20
+ *  end byte = clear pid always a0, other wise 9c, 9a ??
+ *
+*/
+#define LME_ST_ON_W     {0x06, 0x00}
+#define LME_CLEAR_PID   {0x03, 0x02, 0x20, 0xa0}
+#define LME_ZERO_PID    {0x03, 0x06, 0x00, 0x00, 0x01, 0x00, 0x20, 0x9c}
+
+/*  LNB Voltage
+ *  07 XX XX
+ *  offset 1 = 01
+ *  offset 2 = 00=Voltage low 01=Voltage high
+ *
+ *  LNB Power
+ *  03 01 XX
+ *  offset 2 = 00=ON 01=OFF
+ */
+
+#define LME_VOLTAGE_L   {0x07, 0x01, 0x00}
+#define LME_VOLTAGE_H   {0x07, 0x01, 0x01}
+#define LNB_ON          {0x3a, 0x01, 0x00}
+#define LNB_OFF         {0x3a, 0x01, 0x01}
+
+/* Initial stv0288 settings for 7395 Frontend */
+static u8 s7395_inittab[] = {
+        0x01, 0x15,
+        0x02, 0x20,
+        0x03, 0xa0,
+        0x04, 0xa0,
+        0x05, 0x12,
+        0x06, 0x00,
+        0x09, 0x00,
+        0x0a, 0x04,
+        0x0b, 0x00,
+        0x0c, 0x00,
+        0x0d, 0x00,
+        0x0e, 0xc1,
+        0x0f, 0x54,
+        0x11, 0x7a,
+        0x12, 0x03,
+        0x13, 0x48,
+        0x14, 0x84,
+        0x15, 0xc5,
+        0x16, 0xb8,
+        0x17, 0x9c,
+        0x18, 0x00,
+        0x19, 0xa6,
+        0x1a, 0x88,
+        0x1b, 0x8f,
+        0x1c, 0xf0,
+        0x20, 0x0b,
+        0x21, 0x54,
+        0x22, 0xff,
+        0x23, 0x01,
+        0x28, 0x46,
+        0x29, 0x66,
+        0x2a, 0x90,
+        0x2b, 0xfa,
+        0x2c, 0xd9,
+        0x30, 0x0,
+        0x31, 0x1e,
+        0x32, 0x14,
+        0x33, 0x0f,
+        0x34, 0x09,
+        0x35, 0x0c,
+        0x36, 0x05,
+        0x37, 0x2f,
+        0x38, 0x16,
+        0x39, 0xbd,
+        0x3a, 0x0,
+        0x3b, 0x13,
+        0x3c, 0x11,
+        0x3d, 0x30,
+        0x40, 0x63,
+        0x41, 0x04,
+        0x42, 0x20,
+        0x43, 0x00,
+        0x44, 0x00,
+        0x45, 0x00,
+        0x46, 0x00,
+        0x47, 0x00,
+        0x4a, 0x00,
+        0x50, 0x10,
+        0x51, 0x36,
+        0x52, 0x21,
+        0x53, 0x94,
+        0x54, 0xb2,
+        0x55, 0x29,
+        0x56, 0x64,
+        0x57, 0x2b,
+        0x58, 0x54,
+        0x59, 0x86,
+        0x5a, 0x00,
+        0x5b, 0x9b,
+        0x5c, 0x08,
+        0x5d, 0x7f,
+        0x5e, 0xff,
+        0x5f, 0x8d,
+        0x70, 0x0,
+        0x71, 0x0,
+        0x72, 0x0,
+        0x74, 0x0,
+        0x75, 0x0,
+        0x76, 0x0,
+        0x81, 0x0,
+        0x82, 0x3f,
+        0x83, 0x3f,
+        0x84, 0x0,
+        0x85, 0x0,
+        0x88, 0x0,
+        0x89, 0x0,
+        0x8a, 0x0,
+        0x8b, 0x0,
+        0x8c, 0x0,
+        0x90, 0x0,
+        0x91, 0x0,
+        0x92, 0x0,
+        0x93, 0x0,
+        0x94, 0x1c,
+        0x97, 0x0,
+        0xa0, 0x48,
+        0xa1, 0x0,
+        0xb0, 0xb8,
+        0xb1, 0x3a,
+        0xb2, 0x10,
+        0xb3, 0x82,
+        0xb4, 0x80,
+        0xb5, 0x82,
+        0xb6, 0x82,
+        0xb7, 0x82,
+        0xb8, 0x20,
+        0xb9, 0x0,
+        0xf0, 0x0,
+        0xf1, 0x0,
+        0xf2, 0xc0,
+        0xff, 0xff,
+};
+#endif
diff --git a/drivers/media/dvb/dvb-usb/m920x.c b/drivers/media/dvb/dvb-usb/m920x.c
new file mode 100644
index 00000000000..9456792f219
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/m920x.c
@@ -0,0 +1,1093 @@
+/* DVB USB compliant linux driver for MSI Mega Sky 580 DVB-T USB2.0 receiver
+ *
+ * Copyright (C) 2006 Aapo Tahkola (aet@rasterburn.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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+
+#include "m920x.h"
+
+#include "mt352.h"
+#include "mt352_priv.h"
+#include "qt1010.h"
+#include "tda1004x.h"
+#include "tda827x.h"
+
+#include <media/tuner.h>
+#include "tuner-simple.h"
+#include <asm/unaligned.h>
+
+/* debug */
+static int dvb_usb_m920x_debug;
+module_param_named(debug,dvb_usb_m920x_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int m920x_set_filter(struct dvb_usb_device *d, int type, int idx, int pid);
+
+static inline int m920x_read(struct usb_device *udev, u8 request, u16 value,
+                             u16 index, void *data, int size)
+{
+        int ret;
+
+        ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                              request, USB_TYPE_VENDOR | USB_DIR_IN,
+                              value, index, data, size, 2000);
+        if (ret < 0) {
+                printk(KERN_INFO "m920x_read = error: %d\n", ret);
+                return ret;
+        }
+
+        if (ret != size) {
+                deb("m920x_read = no data\n");
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static inline int m920x_write(struct usb_device *udev, u8 request,
+                              u16 value, u16 index)
+{
+        int ret;
+
+        ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                              request, USB_TYPE_VENDOR | USB_DIR_OUT,
+                              value, index, NULL, 0, 2000);
+
+        return ret;
+}
+
+static int m920x_init(struct dvb_usb_device *d, struct m920x_inits *rc_seq)
+{
+        int ret = 0, i, epi, flags = 0;
+        int adap_enabled[M9206_MAX_ADAPTERS] = { 0 };
+
+        /* Remote controller init. */
+        if (d->props.rc.legacy.rc_query) {
+                deb("Initialising remote control\n");
+                while (rc_seq->address) {
+                        if ((ret = m920x_write(d->udev, M9206_CORE,
+                                               rc_seq->data,
+                                               rc_seq->address)) != 0) {
+                                deb("Initialising remote control failed\n");
+                                return ret;
+                        }
+
+                        rc_seq++;
+                }
+
+                deb("Initialising remote control success\n");
+        }
+
+        for (i = 0; i < d->props.num_adapters; i++)
+                flags |= d->adapter[i].props.caps;
+
+        /* Some devices(Dposh) might crash if we attempt touch at all. */
+        if (flags & DVB_USB_ADAP_HAS_PID_FILTER) {
+                for (i = 0; i < d->props.num_adapters; i++) {
+                        epi = d->adapter[i].props.stream.endpoint - 0x81;
+
+                        if (epi < 0 || epi >= M9206_MAX_ADAPTERS) {
+                                printk(KERN_INFO "m920x: Unexpected adapter endpoint!\n");
+                                return -EINVAL;
+                        }
+
+                        adap_enabled[epi] = 1;
+                }
+
+                for (i = 0; i < M9206_MAX_ADAPTERS; i++) {
+                        if (adap_enabled[i])
+                                continue;
+
+                        if ((ret = m920x_set_filter(d, 0x81 + i, 0, 0x0)) != 0)
+                                return ret;
+
+                        if ((ret = m920x_set_filter(d, 0x81 + i, 0, 0x02f5)) != 0)
+                                return ret;
+                }
+        }
+
+        return ret;
+}
+
+static int m920x_init_ep(struct usb_interface *intf)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct usb_host_interface *alt;
+
+        if ((alt = usb_altnum_to_altsetting(intf, 1)) == NULL) {
+                deb("No alt found!\n");
+                return -ENODEV;
+        }
+
+        return usb_set_interface(udev, alt->desc.bInterfaceNumber,
+                                 alt->desc.bAlternateSetting);
+}
+
+static int m920x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        struct m920x_state *m = d->priv;
+        int i, ret = 0;
+        u8 *rc_state;
+
+        rc_state = kmalloc(2, GFP_KERNEL);
+        if (!rc_state)
+                return -ENOMEM;
+
+        if ((ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE, rc_state, 1)) != 0)
+                goto out;
+
+        if ((ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY, rc_state + 1, 1)) != 0)
+                goto out;
+
+        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++)
+                if (rc5_data(&d->props.rc.legacy.rc_map_table[i]) == rc_state[1]) {
+                        *event = d->props.rc.legacy.rc_map_table[i].keycode;
+
+                        switch(rc_state[0]) {
+                        case 0x80:
+                                *state = REMOTE_NO_KEY_PRESSED;
+                                goto out;
+
+                        case 0x88: /* framing error or "invalid code" */
+                        case 0x99:
+                        case 0xc0:
+                        case 0xd8:
+                                *state = REMOTE_NO_KEY_PRESSED;
+                                m->rep_count = 0;
+                                goto out;
+
+                        case 0x93:
+                        case 0x92:
+                        case 0x83: /* pinnacle PCTV310e */
+                        case 0x82:
+                                m->rep_count = 0;
+                                *state = REMOTE_KEY_PRESSED;
+                                goto out;
+
+                        case 0x91:
+                        case 0x81: /* pinnacle PCTV310e */
+                                /* prevent immediate auto-repeat */
+                                if (++m->rep_count > 2)
+                                        *state = REMOTE_KEY_REPEAT;
+                                else
+                                        *state = REMOTE_NO_KEY_PRESSED;
+                                goto out;
+
+                        default:
+                                deb("Unexpected rc state %02x\n", rc_state[0]);
+                                *state = REMOTE_NO_KEY_PRESSED;
+                                goto out;
+                        }
+                }
+
+        if (rc_state[1] != 0)
+                deb("Unknown rc key %02x\n", rc_state[1]);
+
+        *state = REMOTE_NO_KEY_PRESSED;
+
+ out:
+        kfree(rc_state);
+        return ret;
+}
+
+/* I2C */
+static int m920x_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i, j;
+        int ret = 0;
+
+        if (!num)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                if (msg[i].flags & (I2C_M_NO_RD_ACK | I2C_M_IGNORE_NAK | I2C_M_TEN) || msg[i].len == 0) {
+                        /* For a 0 byte message, I think sending the address
+                         * to index 0x80|0x40 would be the correct thing to
+                         * do.  However, zero byte messages are only used for
+                         * probing, and since we don't know how to get the
+                         * slave's ack, we can't probe. */
+                        ret = -ENOTSUPP;
+                        goto unlock;
+                }
+                /* Send START & address/RW bit */
+                if (!(msg[i].flags & I2C_M_NOSTART)) {
+                        if ((ret = m920x_write(d->udev, M9206_I2C,
+                                        (msg[i].addr << 1) |
+                                        (msg[i].flags & I2C_M_RD ? 0x01 : 0), 0x80)) != 0)
+                                goto unlock;
+                        /* Should check for ack here, if we knew how. */
+                }
+                if (msg[i].flags & I2C_M_RD) {
+                        for (j = 0; j < msg[i].len; j++) {
+                                /* Last byte of transaction?
+                                 * Send STOP, otherwise send ACK. */
+                                int stop = (i+1 == num && j+1 == msg[i].len) ? 0x40 : 0x01;
+
+                                if ((ret = m920x_read(d->udev, M9206_I2C, 0x0,
+                                                      0x20 | stop,
+                                                      &msg[i].buf[j], 1)) != 0)
+                                        goto unlock;
+                        }
+                } else {
+                        for (j = 0; j < msg[i].len; j++) {
+                                /* Last byte of transaction? Then send STOP. */
+                                int stop = (i+1 == num && j+1 == msg[i].len) ? 0x40 : 0x00;
+
+                                if ((ret = m920x_write(d->udev, M9206_I2C, msg[i].buf[j], stop)) != 0)
+                                        goto unlock;
+                                /* Should check for ack here too. */
+                        }
+                }
+        }
+        ret = num;
+
+ unlock:
+        mutex_unlock(&d->i2c_mutex);
+
+        return ret;
+}
+
+static u32 m920x_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm m920x_i2c_algo = {
+        .master_xfer   = m920x_i2c_xfer,
+        .functionality = m920x_i2c_func,
+};
+
+/* pid filter */
+static int m920x_set_filter(struct dvb_usb_device *d, int type, int idx, int pid)
+{
+        int ret = 0;
+
+        if (pid >= 0x8000)
+                return -EINVAL;
+
+        pid |= 0x8000;
+
+        if ((ret = m920x_write(d->udev, M9206_FILTER, pid, (type << 8) | (idx * 4) )) != 0)
+                return ret;
+
+        if ((ret = m920x_write(d->udev, M9206_FILTER, 0, (type << 8) | (idx * 4) )) != 0)
+                return ret;
+
+        return ret;
+}
+
+static int m920x_update_filters(struct dvb_usb_adapter *adap)
+{
+        struct m920x_state *m = adap->dev->priv;
+        int enabled = m->filtering_enabled[adap->id];
+        int i, ret = 0, filter = 0;
+        int ep = adap->props.stream.endpoint;
+
+        for (i = 0; i < M9206_MAX_FILTERS; i++)
+                if (m->filters[adap->id][i] == 8192)
+                        enabled = 0;
+
+        /* Disable all filters */
+        if ((ret = m920x_set_filter(adap->dev, ep, 1, enabled)) != 0)
+                return ret;
+
+        for (i = 0; i < M9206_MAX_FILTERS; i++)
+                if ((ret = m920x_set_filter(adap->dev, ep, i + 2, 0)) != 0)
+                        return ret;
+
+        /* Set */
+        if (enabled) {
+                for (i = 0; i < M9206_MAX_FILTERS; i++) {
+                        if (m->filters[adap->id][i] == 0)
+                                continue;
+
+                        if ((ret = m920x_set_filter(adap->dev, ep, filter + 2, m->filters[adap->id][i])) != 0)
+                                return ret;
+
+                        filter++;
+                }
+        }
+
+        return ret;
+}
+
+static int m920x_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        struct m920x_state *m = adap->dev->priv;
+
+        m->filtering_enabled[adap->id] = onoff ? 1 : 0;
+
+        return m920x_update_filters(adap);
+}
+
+static int m920x_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff)
+{
+        struct m920x_state *m = adap->dev->priv;
+
+        m->filters[adap->id][index] = onoff ? pid : 0;
+
+        return m920x_update_filters(adap);
+}
+
+static int m920x_firmware_download(struct usb_device *udev, const struct firmware *fw)
+{
+        u16 value, index, size;
+        u8 *read, *buff;
+        int i, pass, ret = 0;
+
+        buff = kmalloc(65536, GFP_KERNEL);
+        if (buff == NULL)
+                return -ENOMEM;
+
+        read = kmalloc(4, GFP_KERNEL);
+        if (!read) {
+                kfree(buff);
+                return -ENOMEM;
+        }
+
+        if ((ret = m920x_read(udev, M9206_FILTER, 0x0, 0x8000, read, 4)) != 0)
+                goto done;
+        deb("%x %x %x %x\n", read[0], read[1], read[2], read[3]);
+
+        if ((ret = m920x_read(udev, M9206_FW, 0x0, 0x0, read, 1)) != 0)
+                goto done;
+        deb("%x\n", read[0]);
+
+        for (pass = 0; pass < 2; pass++) {
+                for (i = 0; i + (sizeof(u16) * 3) < fw->size;) {
+                        value = get_unaligned_le16(fw->data + i);
+                        i += sizeof(u16);
+
+                        index = get_unaligned_le16(fw->data + i);
+                        i += sizeof(u16);
+
+                        size = get_unaligned_le16(fw->data + i);
+                        i += sizeof(u16);
+
+                        if (pass == 1) {
+                                /* Will stall if using fw->data ... */
+                                memcpy(buff, fw->data + i, size);
+
+                                ret = usb_control_msg(udev, usb_sndctrlpipe(udev,0),
+                                                      M9206_FW,
+                                                      USB_TYPE_VENDOR | USB_DIR_OUT,
+                                                      value, index, buff, size, 20);
+                                if (ret != size) {
+                                        deb("error while uploading fw!\n");
+                                        ret = -EIO;
+                                        goto done;
+                                }
+                                msleep(3);
+                        }
+                        i += size;
+                }
+                if (i != fw->size) {
+                        deb("bad firmware file!\n");
+                        ret = -EINVAL;
+                        goto done;
+                }
+        }
+
+        msleep(36);
+
+        /* m920x will disconnect itself from the bus after this. */
+        (void) m920x_write(udev, M9206_CORE, 0x01, M9206_FW_GO);
+        deb("firmware uploaded!\n");
+
+ done:
+        kfree(read);
+        kfree(buff);
+
+        return ret;
+}
+
+/* Callbacks for DVB USB */
+static int m920x_identify_state(struct usb_device *udev,
+                                struct dvb_usb_device_properties *props,
+                                struct dvb_usb_device_description **desc,
+                                int *cold)
+{
+        struct usb_host_interface *alt;
+
+        alt = usb_altnum_to_altsetting(usb_ifnum_to_if(udev, 0), 1);
+        *cold = (alt == NULL) ? 1 : 0;
+
+        return 0;
+}
+
+/* demod configurations */
+static int m920x_mt352_demod_init(struct dvb_frontend *fe)
+{
+        int ret;
+        u8 config[] = { CONFIG, 0x3d };
+        u8 clock[] = { CLOCK_CTL, 0x30 };
+        u8 reset[] = { RESET, 0x80 };
+        u8 adc_ctl[] = { ADC_CTL_1, 0x40 };
+        u8 agc[] = { AGC_TARGET, 0x1c, 0x20 };
+        u8 sec_agc[] = { 0x69, 0x00, 0xff, 0xff, 0x40, 0xff, 0x00, 0x40, 0x40 };
+        u8 unk1[] = { 0x93, 0x1a };
+        u8 unk2[] = { 0xb5, 0x7a };
+
+        deb("Demod init!\n");
+
+        if ((ret = mt352_write(fe, config, ARRAY_SIZE(config))) != 0)
+                return ret;
+        if ((ret = mt352_write(fe, clock, ARRAY_SIZE(clock))) != 0)
+                return ret;
+        if ((ret = mt352_write(fe, reset, ARRAY_SIZE(reset))) != 0)
+                return ret;
+        if ((ret = mt352_write(fe, adc_ctl, ARRAY_SIZE(adc_ctl))) != 0)
+                return ret;
+        if ((ret = mt352_write(fe, agc, ARRAY_SIZE(agc))) != 0)
+                return ret;
+        if ((ret = mt352_write(fe, sec_agc, ARRAY_SIZE(sec_agc))) != 0)
+                return ret;
+        if ((ret = mt352_write(fe, unk1, ARRAY_SIZE(unk1))) != 0)
+                return ret;
+        if ((ret = mt352_write(fe, unk2, ARRAY_SIZE(unk2))) != 0)
+                return ret;
+
+        return 0;
+}
+
+static struct mt352_config m920x_mt352_config = {
+        .demod_address = 0x0f,
+        .no_tuner = 1,
+        .demod_init = m920x_mt352_demod_init,
+};
+
+static struct tda1004x_config m920x_tda10046_08_config = {
+        .demod_address = 0x08,
+        .invert = 0,
+        .invert_oclk = 0,
+        .ts_mode = TDA10046_TS_SERIAL,
+        .xtal_freq = TDA10046_XTAL_16M,
+        .if_freq = TDA10046_FREQ_045,
+        .agc_config = TDA10046_AGC_TDA827X,
+        .gpio_config = TDA10046_GPTRI,
+        .request_firmware = NULL,
+};
+
+static struct tda1004x_config m920x_tda10046_0b_config = {
+        .demod_address = 0x0b,
+        .invert = 0,
+        .invert_oclk = 0,
+        .ts_mode = TDA10046_TS_SERIAL,
+        .xtal_freq = TDA10046_XTAL_16M,
+        .if_freq = TDA10046_FREQ_045,
+        .agc_config = TDA10046_AGC_TDA827X,
+        .gpio_config = TDA10046_GPTRI,
+        .request_firmware = NULL, /* uses firmware EEPROM */
+};
+
+/* tuner configurations */
+static struct qt1010_config m920x_qt1010_config = {
+        .i2c_address = 0x62
+};
+
+/* Callbacks for DVB USB */
+static int m920x_mt352_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        deb("%s\n",__func__);
+
+        if ((adap->fe = dvb_attach(mt352_attach,
+                                   &m920x_mt352_config,
+                                   &adap->dev->i2c_adap)) == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+static int m920x_tda10046_08_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        deb("%s\n",__func__);
+
+        if ((adap->fe = dvb_attach(tda10046_attach,
+                                   &m920x_tda10046_08_config,
+                                   &adap->dev->i2c_adap)) == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+static int m920x_tda10046_0b_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        deb("%s\n",__func__);
+
+        if ((adap->fe = dvb_attach(tda10046_attach,
+                                   &m920x_tda10046_0b_config,
+                                   &adap->dev->i2c_adap)) == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+static int m920x_qt1010_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        deb("%s\n",__func__);
+
+        if (dvb_attach(qt1010_attach, adap->fe, &adap->dev->i2c_adap, &m920x_qt1010_config) == NULL)
+                return -ENODEV;
+
+        return 0;
+}
+
+static int m920x_tda8275_60_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        deb("%s\n",__func__);
+
+        if (dvb_attach(tda827x_attach, adap->fe, 0x60, &adap->dev->i2c_adap, NULL) == NULL)
+                return -ENODEV;
+
+        return 0;
+}
+
+static int m920x_tda8275_61_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        deb("%s\n",__func__);
+
+        if (dvb_attach(tda827x_attach, adap->fe, 0x61, &adap->dev->i2c_adap, NULL) == NULL)
+                return -ENODEV;
+
+        return 0;
+}
+
+static int m920x_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(simple_tuner_attach, adap->fe,
+                   &adap->dev->i2c_adap, 0x61,
+                   TUNER_PHILIPS_FMD1216ME_MK3);
+        return 0;
+}
+
+/* device-specific initialization */
+static struct m920x_inits megasky_rc_init [] = {
+        { M9206_RC_INIT2, 0xa8 },
+        { M9206_RC_INIT1, 0x51 },
+        { } /* terminating entry */
+};
+
+static struct m920x_inits tvwalkertwin_rc_init [] = {
+        { M9206_RC_INIT2, 0x00 },
+        { M9206_RC_INIT1, 0xef },
+        { 0xff28,         0x00 },
+        { 0xff23,         0x00 },
+        { 0xff21,         0x30 },
+        { } /* terminating entry */
+};
+
+static struct m920x_inits pinnacle310e_init[] = {
+        /* without these the tuner don't work */
+        { 0xff20,         0x9b },
+        { 0xff22,         0x70 },
+
+        /* rc settings */
+        { 0xff50,         0x80 },
+        { M9206_RC_INIT1, 0x00 },
+        { M9206_RC_INIT2, 0xff },
+        { } /* terminating entry */
+};
+
+/* ir keymaps */
+static struct rc_map_table rc_map_megasky_table[] = {
+        { 0x0012, KEY_POWER },
+        { 0x001e, KEY_CYCLEWINDOWS }, /* min/max */
+        { 0x0002, KEY_CHANNELUP },
+        { 0x0005, KEY_CHANNELDOWN },
+        { 0x0003, KEY_VOLUMEUP },
+        { 0x0006, KEY_VOLUMEDOWN },
+        { 0x0004, KEY_MUTE },
+        { 0x0007, KEY_OK }, /* TS */
+        { 0x0008, KEY_STOP },
+        { 0x0009, KEY_MENU }, /* swap */
+        { 0x000a, KEY_REWIND },
+        { 0x001b, KEY_PAUSE },
+        { 0x001f, KEY_FASTFORWARD },
+        { 0x000c, KEY_RECORD },
+        { 0x000d, KEY_CAMERA }, /* screenshot */
+        { 0x000e, KEY_COFFEE }, /* "MTS" */
+};
+
+static struct rc_map_table rc_map_tvwalkertwin_table[] = {
+        { 0x0001, KEY_ZOOM }, /* Full Screen */
+        { 0x0002, KEY_CAMERA }, /* snapshot */
+        { 0x0003, KEY_MUTE },
+        { 0x0004, KEY_REWIND },
+        { 0x0005, KEY_PLAYPAUSE }, /* Play/Pause */
+        { 0x0006, KEY_FASTFORWARD },
+        { 0x0007, KEY_RECORD },
+        { 0x0008, KEY_STOP },
+        { 0x0009, KEY_TIME }, /* Timeshift */
+        { 0x000c, KEY_COFFEE }, /* Recall */
+        { 0x000e, KEY_CHANNELUP },
+        { 0x0012, KEY_POWER },
+        { 0x0015, KEY_MENU }, /* source */
+        { 0x0018, KEY_CYCLEWINDOWS }, /* TWIN PIP */
+        { 0x001a, KEY_CHANNELDOWN },
+        { 0x001b, KEY_VOLUMEDOWN },
+        { 0x001e, KEY_VOLUMEUP },
+};
+
+static struct rc_map_table rc_map_pinnacle310e_table[] = {
+        { 0x16, KEY_POWER },
+        { 0x17, KEY_FAVORITES },
+        { 0x0f, KEY_TEXT },
+        { 0x48, KEY_PROGRAM },          /* preview */
+        { 0x1c, KEY_EPG },
+        { 0x04, KEY_LIST },             /* record list */
+        { 0x03, KEY_1 },
+        { 0x01, KEY_2 },
+        { 0x06, KEY_3 },
+        { 0x09, KEY_4 },
+        { 0x1d, KEY_5 },
+        { 0x1f, KEY_6 },
+        { 0x0d, KEY_7 },
+        { 0x19, KEY_8 },
+        { 0x1b, KEY_9 },
+        { 0x15, KEY_0 },
+        { 0x0c, KEY_CANCEL },
+        { 0x4a, KEY_CLEAR },
+        { 0x13, KEY_BACK },
+        { 0x00, KEY_TAB },
+        { 0x4b, KEY_UP },
+        { 0x4e, KEY_LEFT },
+        { 0x52, KEY_RIGHT },
+        { 0x51, KEY_DOWN },
+        { 0x4f, KEY_ENTER },            /* could also be KEY_OK */
+        { 0x1e, KEY_VOLUMEUP },
+        { 0x0a, KEY_VOLUMEDOWN },
+        { 0x05, KEY_CHANNELUP },
+        { 0x02, KEY_CHANNELDOWN },
+        { 0x11, KEY_RECORD },
+        { 0x14, KEY_PLAY },
+        { 0x4c, KEY_PAUSE },
+        { 0x1a, KEY_STOP },
+        { 0x40, KEY_REWIND },
+        { 0x12, KEY_FASTFORWARD },
+        { 0x41, KEY_PREVIOUSSONG },     /* Replay */
+        { 0x42, KEY_NEXTSONG },         /* Skip */
+        { 0x54, KEY_CAMERA },           /* Capture */
+/*      { 0x50, KEY_SAP },      */              /* Sap */
+        { 0x47, KEY_CYCLEWINDOWS },     /* Pip */
+        { 0x4d, KEY_SCREEN },           /* FullScreen */
+        { 0x08, KEY_SUBTITLE },
+        { 0x0e, KEY_MUTE },
+/*      { 0x49, KEY_LR },       */              /* L/R */
+        { 0x07, KEY_SLEEP },            /* Hibernate */
+        { 0x08, KEY_VIDEO },            /* A/V */
+        { 0x0e, KEY_MENU },             /* Recall */
+        { 0x45, KEY_ZOOMIN },
+        { 0x46, KEY_ZOOMOUT },
+        { 0x18, KEY_RED },              /* Red */
+        { 0x53, KEY_GREEN },            /* Green */
+        { 0x5e, KEY_YELLOW },           /* Yellow */
+        { 0x5f, KEY_BLUE },             /* Blue */
+};
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties megasky_properties;
+static struct dvb_usb_device_properties digivox_mini_ii_properties;
+static struct dvb_usb_device_properties tvwalkertwin_properties;
+static struct dvb_usb_device_properties dposh_properties;
+static struct dvb_usb_device_properties pinnacle_pctv310e_properties;
+
+static int m920x_probe(struct usb_interface *intf,
+                       const struct usb_device_id *id)
+{
+        struct dvb_usb_device *d = NULL;
+        int ret;
+        struct m920x_inits *rc_init_seq = NULL;
+        int bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
+
+        deb("Probing for m920x device at interface %d\n", bInterfaceNumber);
+
+        if (bInterfaceNumber == 0) {
+                /* Single-tuner device, or first interface on
+                 * multi-tuner device
+                 */
+
+                ret = dvb_usb_device_init(intf, &megasky_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
+                        rc_init_seq = megasky_rc_init;
+                        goto found;
+                }
+
+                ret = dvb_usb_device_init(intf, &digivox_mini_ii_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
+                        /* No remote control, so no rc_init_seq */
+                        goto found;
+                }
+
+                /* This configures both tuners on the TV Walker Twin */
+                ret = dvb_usb_device_init(intf, &tvwalkertwin_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
+                        rc_init_seq = tvwalkertwin_rc_init;
+                        goto found;
+                }
+
+                ret = dvb_usb_device_init(intf, &dposh_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
+                        /* Remote controller not supported yet. */
+                        goto found;
+                }
+
+                ret = dvb_usb_device_init(intf, &pinnacle_pctv310e_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
+                        rc_init_seq = pinnacle310e_init;
+                        goto found;
+                }
+
+                return ret;
+        } else {
+                /* Another interface on a multi-tuner device */
+
+                /* The LifeView TV Walker Twin gets here, but struct
+                 * tvwalkertwin_properties already configured both
+                 * tuners, so there is nothing for us to do here
+                 */
+        }
+
+ found:
+        if ((ret = m920x_init_ep(intf)) < 0)
+                return ret;
+
+        if (d && (ret = m920x_init(d, rc_init_seq)) != 0)
+                return ret;
+
+        return ret;
+}
+
+static struct usb_device_id m920x_table [] = {
+                { USB_DEVICE(USB_VID_MSI, USB_PID_MSI_MEGASKY580) },
+                { USB_DEVICE(USB_VID_ANUBIS_ELECTRONIC,
+                             USB_PID_MSI_DIGI_VOX_MINI_II) },
+                { USB_DEVICE(USB_VID_ANUBIS_ELECTRONIC,
+                             USB_PID_LIFEVIEW_TV_WALKER_TWIN_COLD) },
+                { USB_DEVICE(USB_VID_ANUBIS_ELECTRONIC,
+                             USB_PID_LIFEVIEW_TV_WALKER_TWIN_WARM) },
+                { USB_DEVICE(USB_VID_DPOSH, USB_PID_DPOSH_M9206_COLD) },
+                { USB_DEVICE(USB_VID_DPOSH, USB_PID_DPOSH_M9206_WARM) },
+                { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_PINNACLE_PCTV310E) },
+                { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, m920x_table);
+
+static struct dvb_usb_device_properties megasky_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "dvb-usb-megasky-02.fw",
+        .download_firmware = m920x_firmware_download,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_megasky_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_megasky_table),
+                .rc_query         = m920x_rc_query,
+        },
+
+        .size_of_priv     = sizeof(struct m920x_state),
+
+        .identify_state   = m920x_identify_state,
+        .num_adapters = 1,
+        .adapter = {{
+                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                .pid_filter_count = 8,
+                .pid_filter       = m920x_pid_filter,
+                .pid_filter_ctrl  = m920x_pid_filter_ctrl,
+
+                .frontend_attach  = m920x_mt352_frontend_attach,
+                .tuner_attach     = m920x_qt1010_tuner_attach,
+
+                .stream = {
+                        .type = USB_BULK,
+                        .count = 8,
+                        .endpoint = 0x81,
+                        .u = {
+                                .bulk = {
+                                        .buffersize = 512,
+                                }
+                        }
+                },
+        }},
+        .i2c_algo         = &m920x_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "MSI Mega Sky 580 DVB-T USB2.0",
+                        { &m920x_table[0], NULL },
+                        { NULL },
+                }
+        }
+};
+
+static struct dvb_usb_device_properties digivox_mini_ii_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "dvb-usb-digivox-02.fw",
+        .download_firmware = m920x_firmware_download,
+
+        .size_of_priv     = sizeof(struct m920x_state),
+
+        .identify_state   = m920x_identify_state,
+        .num_adapters = 1,
+        .adapter = {{
+                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                .pid_filter_count = 8,
+                .pid_filter       = m920x_pid_filter,
+                .pid_filter_ctrl  = m920x_pid_filter_ctrl,
+
+                .frontend_attach  = m920x_tda10046_08_frontend_attach,
+                .tuner_attach     = m920x_tda8275_60_tuner_attach,
+
+                .stream = {
+                        .type = USB_BULK,
+                        .count = 8,
+                        .endpoint = 0x81,
+                        .u = {
+                                .bulk = {
+                                        .buffersize = 0x4000,
+                                }
+                        }
+                },
+        }},
+        .i2c_algo         = &m920x_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "MSI DIGI VOX mini II DVB-T USB2.0",
+                        { &m920x_table[1], NULL },
+                        { NULL },
+                },
+        }
+};
+
+/* LifeView TV Walker Twin support by Nick Andrew <nick@nick-andrew.net>
+ *
+ * LifeView TV Walker Twin has 1 x M9206, 2 x TDA10046, 2 x TDA8275A
+ * TDA10046 #0 is located at i2c address 0x08
+ * TDA10046 #1 is located at i2c address 0x0b
+ * TDA8275A #0 is located at i2c address 0x60
+ * TDA8275A #1 is located at i2c address 0x61
+ */
+static struct dvb_usb_device_properties tvwalkertwin_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "dvb-usb-tvwalkert.fw",
+        .download_firmware = m920x_firmware_download,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_tvwalkertwin_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_tvwalkertwin_table),
+                .rc_query         = m920x_rc_query,
+        },
+
+        .size_of_priv     = sizeof(struct m920x_state),
+
+        .identify_state   = m920x_identify_state,
+        .num_adapters = 2,
+        .adapter = {{
+                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                .pid_filter_count = 8,
+                .pid_filter       = m920x_pid_filter,
+                .pid_filter_ctrl  = m920x_pid_filter_ctrl,
+
+                .frontend_attach  = m920x_tda10046_08_frontend_attach,
+                .tuner_attach     = m920x_tda8275_60_tuner_attach,
+
+                .stream = {
+                        .type = USB_BULK,
+                        .count = 8,
+                        .endpoint = 0x81,
+                        .u = {
+                                 .bulk = {
+                                         .buffersize = 512,
+                                 }
+                        }
+                }},{
+                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                .pid_filter_count = 8,
+                .pid_filter       = m920x_pid_filter,
+                .pid_filter_ctrl  = m920x_pid_filter_ctrl,
+
+                .frontend_attach  = m920x_tda10046_0b_frontend_attach,
+                .tuner_attach     = m920x_tda8275_61_tuner_attach,
+
+                .stream = {
+                        .type = USB_BULK,
+                        .count = 8,
+                        .endpoint = 0x82,
+                        .u = {
+                                 .bulk = {
+                                         .buffersize = 512,
+                                 }
+                        }
+                },
+        }},
+        .i2c_algo         = &m920x_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   .name = "LifeView TV Walker Twin DVB-T USB2.0",
+                    .cold_ids = { &m920x_table[2], NULL },
+                    .warm_ids = { &m920x_table[3], NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties dposh_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "dvb-usb-dposh-01.fw",
+        .download_firmware = m920x_firmware_download,
+
+        .size_of_priv     = sizeof(struct m920x_state),
+
+        .identify_state   = m920x_identify_state,
+        .num_adapters = 1,
+        .adapter = {{
+                /* Hardware pid filters don't work with this device/firmware */
+
+                .frontend_attach  = m920x_mt352_frontend_attach,
+                .tuner_attach     = m920x_qt1010_tuner_attach,
+
+                .stream = {
+                        .type = USB_BULK,
+                        .count = 8,
+                        .endpoint = 0x81,
+                        .u = {
+                                 .bulk = {
+                                         .buffersize = 512,
+                                 }
+                        }
+                },
+        }},
+        .i2c_algo         = &m920x_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                 {   .name = "Dposh DVB-T USB2.0",
+                     .cold_ids = { &m920x_table[4], NULL },
+                     .warm_ids = { &m920x_table[5], NULL },
+                 },
+         }
+};
+
+static struct dvb_usb_device_properties pinnacle_pctv310e_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .download_firmware = NULL,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_pinnacle310e_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_pinnacle310e_table),
+                .rc_query         = m920x_rc_query,
+        },
+
+        .size_of_priv     = sizeof(struct m920x_state),
+
+        .identify_state   = m920x_identify_state,
+        .num_adapters = 1,
+        .adapter = {{
+                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                .pid_filter_count = 8,
+                .pid_filter       = m920x_pid_filter,
+                .pid_filter_ctrl  = m920x_pid_filter_ctrl,
+
+                .frontend_attach  = m920x_mt352_frontend_attach,
+                .tuner_attach     = m920x_fmd1216me_tuner_attach,
+
+                .stream = {
+                        .type = USB_ISOC,
+                        .count = 5,
+                        .endpoint = 0x84,
+                        .u = {
+                                .isoc = {
+                                        .framesperurb = 128,
+                                        .framesize = 564,
+                                        .interval = 1,
+                                }
+                        }
+                },
+        } },
+        .i2c_algo         = &m920x_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "Pinnacle PCTV 310e",
+                        { &m920x_table[6], NULL },
+                        { NULL },
+                }
+        }
+};
+
+static struct usb_driver m920x_driver = {
+        .name           = "dvb_usb_m920x",
+        .probe          = m920x_probe,
+        .disconnect     = dvb_usb_device_exit,
+        .id_table       = m920x_table,
+};
+
+/* module stuff */
+static int __init m920x_module_init(void)
+{
+        int ret;
+
+        if ((ret = usb_register(&m920x_driver))) {
+                err("usb_register failed. Error number %d", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static void __exit m920x_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&m920x_driver);
+}
+
+module_init (m920x_module_init);
+module_exit (m920x_module_exit);
+
+MODULE_AUTHOR("Aapo Tahkola <aet@rasterburn.org>");
+MODULE_DESCRIPTION("DVB Driver for ULI M920x");
+MODULE_VERSION("0.1");
+MODULE_LICENSE("GPL");
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ */
diff --git a/drivers/media/dvb/dvb-usb/m920x.h b/drivers/media/dvb/dvb-usb/m920x.h
new file mode 100644
index 00000000000..3c061518ffc
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/m920x.h
@@ -0,0 +1,77 @@
+#ifndef _DVB_USB_M920X_H_
+#define _DVB_USB_M920X_H_
+
+#define DVB_USB_LOG_PREFIX "m920x"
+#include "dvb-usb.h"
+
+#define deb(args...)   dprintk(dvb_usb_m920x_debug,0x01,args)
+
+#define M9206_CORE      0x22
+#define M9206_RC_STATE  0xff51
+#define M9206_RC_KEY    0xff52
+#define M9206_RC_INIT1  0xff54
+#define M9206_RC_INIT2  0xff55
+#define M9206_FW_GO     0xff69
+
+#define M9206_I2C       0x23
+#define M9206_FILTER    0x25
+#define M9206_FW        0x30
+
+#define M9206_MAX_FILTERS 8
+#define M9206_MAX_ADAPTERS 4
+
+/*
+sequences found in logs:
+[index value]
+0x80 write addr
+(0x00 out byte)*
+0x40 out byte
+
+0x80 write addr
+(0x00 out byte)*
+0x80 read addr
+(0x21 in byte)*
+0x60 in byte
+
+this sequence works:
+0x80 read addr
+(0x21 in byte)*
+0x60 in byte
+
+Guess at API of the I2C function:
+I2C operation is done one byte at a time with USB control messages.  The
+index the messages is sent to is made up of a set of flags that control
+the I2C bus state:
+0x80:  Send START condition.  After a START condition, one would normally
+       always send the 7-bit slave I2C address as the 7 MSB, followed by
+       the read/write bit as the LSB.
+0x40:  Send STOP condition.  This should be set on the last byte of an
+       I2C transaction.
+0x20:  Read a byte from the slave.  As opposed to writing a byte to the
+       slave.  The slave will normally not produce any data unless you
+       set the R/W bit to 1 when sending the slave's address after the
+       START condition.
+0x01:  Respond with ACK, as opposed to a NACK.  For a multi-byte read,
+       the master should send an ACK, that is pull SDA low during the 9th
+       clock cycle, after every byte but the last.  This flags only makes
+       sense when bit 0x20 is set, indicating a read.
+
+What any other bits might mean, or how to get the slave's ACK/NACK
+response to a write, is unknown.
+*/
+
+struct m920x_state {
+        u16 filters[M9206_MAX_ADAPTERS][M9206_MAX_FILTERS];
+        int filtering_enabled[M9206_MAX_ADAPTERS];
+        int rep_count;
+};
+
+/* Initialisation data for the m920x
+ */
+
+struct m920x_inits {
+        u16 address;
+        u8  data;
+};
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/nova-t-usb2.c b/drivers/media/dvb/dvb-usb/nova-t-usb2.c
new file mode 100644
index 00000000000..bc350e982b7
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/nova-t-usb2.c
@@ -0,0 +1,250 @@
+/* DVB USB framework compliant Linux driver for the Hauppauge WinTV-NOVA-T usb2
+ * DVB-T receiver.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dibusb.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=rc,2=eeprom (|-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+#define deb_rc(args...) dprintk(debug,0x01,args)
+#define deb_ee(args...) dprintk(debug,0x02,args)
+
+/* Hauppauge NOVA-T USB2 keys */
+static struct rc_map_table rc_map_haupp_table[] = {
+        { 0x1e00, KEY_0 },
+        { 0x1e01, KEY_1 },
+        { 0x1e02, KEY_2 },
+        { 0x1e03, KEY_3 },
+        { 0x1e04, KEY_4 },
+        { 0x1e05, KEY_5 },
+        { 0x1e06, KEY_6 },
+        { 0x1e07, KEY_7 },
+        { 0x1e08, KEY_8 },
+        { 0x1e09, KEY_9 },
+        { 0x1e0a, KEY_KPASTERISK },
+        { 0x1e0b, KEY_RED },
+        { 0x1e0c, KEY_RADIO },
+        { 0x1e0d, KEY_MENU },
+        { 0x1e0e, KEY_GRAVE }, /* # */
+        { 0x1e0f, KEY_MUTE },
+        { 0x1e10, KEY_VOLUMEUP },
+        { 0x1e11, KEY_VOLUMEDOWN },
+        { 0x1e12, KEY_CHANNEL },
+        { 0x1e14, KEY_UP },
+        { 0x1e15, KEY_DOWN },
+        { 0x1e16, KEY_LEFT },
+        { 0x1e17, KEY_RIGHT },
+        { 0x1e18, KEY_VIDEO },
+        { 0x1e19, KEY_AUDIO },
+        { 0x1e1a, KEY_IMAGES },
+        { 0x1e1b, KEY_EPG },
+        { 0x1e1c, KEY_TV },
+        { 0x1e1e, KEY_NEXT },
+        { 0x1e1f, KEY_BACK },
+        { 0x1e20, KEY_CHANNELUP },
+        { 0x1e21, KEY_CHANNELDOWN },
+        { 0x1e24, KEY_LAST }, /* Skip backwards */
+        { 0x1e25, KEY_OK },
+        { 0x1e29, KEY_BLUE},
+        { 0x1e2e, KEY_GREEN },
+        { 0x1e30, KEY_PAUSE },
+        { 0x1e32, KEY_REWIND },
+        { 0x1e34, KEY_FASTFORWARD },
+        { 0x1e35, KEY_PLAY },
+        { 0x1e36, KEY_STOP },
+        { 0x1e37, KEY_RECORD },
+        { 0x1e38, KEY_YELLOW },
+        { 0x1e3b, KEY_GOTO },
+        { 0x1e3d, KEY_POWER },
+};
+
+/* Firmware bug? sometimes, when a new key is pressed, the previous pressed key
+ * is delivered. No workaround yet, maybe a new firmware.
+ */
+static int nova_t_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        u8 key[5],cmd[2] = { DIBUSB_REQ_POLL_REMOTE, 0x35 }, data,toggle,custom;
+        u16 raw;
+        int i;
+        struct dibusb_device_state *st = d->priv;
+
+        dvb_usb_generic_rw(d,cmd,2,key,5,0);
+
+        *state = REMOTE_NO_KEY_PRESSED;
+        switch (key[0]) {
+                case DIBUSB_RC_HAUPPAUGE_KEY_PRESSED:
+                        raw = ((key[1] << 8) | key[2]) >> 3;
+                        toggle = !!(raw & 0x800);
+                        data = raw & 0x3f;
+                        custom = (raw >> 6) & 0x1f;
+
+                        deb_rc("raw key code 0x%02x, 0x%02x, 0x%02x to c: %02x d: %02x toggle: %d\n",key[1],key[2],key[3],custom,data,toggle);
+
+                        for (i = 0; i < ARRAY_SIZE(rc_map_haupp_table); i++) {
+                                if (rc5_data(&rc_map_haupp_table[i]) == data &&
+                                        rc5_custom(&rc_map_haupp_table[i]) == custom) {
+
+                                        deb_rc("c: %x, d: %x\n", rc5_data(&rc_map_haupp_table[i]),
+                                                                 rc5_custom(&rc_map_haupp_table[i]));
+
+                                        *event = rc_map_haupp_table[i].keycode;
+                                        *state = REMOTE_KEY_PRESSED;
+                                        if (st->old_toggle == toggle) {
+                                                if (st->last_repeat_count++ < 2)
+                                                        *state = REMOTE_NO_KEY_PRESSED;
+                                        } else {
+                                                st->last_repeat_count = 0;
+                                                st->old_toggle = toggle;
+                                        }
+                                        break;
+                                }
+                        }
+
+                        break;
+                case DIBUSB_RC_HAUPPAUGE_KEY_EMPTY:
+                default:
+                        break;
+        }
+
+        return 0;
+}
+
+static int nova_t_read_mac_address (struct dvb_usb_device *d, u8 mac[6])
+{
+        int i;
+        u8 b;
+
+        mac[0] = 0x00;
+        mac[1] = 0x0d;
+        mac[2] = 0xfe;
+
+        /* this is a complete guess, but works for my box */
+        for (i = 136; i < 139; i++) {
+                dibusb_read_eeprom_byte(d,i, &b);
+
+                mac[5 - (i - 136)] = b;
+        }
+
+        return 0;
+}
+
+/* USB Driver stuff */
+static struct dvb_usb_device_properties nova_t_properties;
+
+static int nova_t_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        return dvb_usb_device_init(intf, &nova_t_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
+}
+
+/* do not change the order of the ID table */
+static struct usb_device_id nova_t_table [] = {
+/* 00 */        { USB_DEVICE(USB_VID_HAUPPAUGE,     USB_PID_WINTV_NOVA_T_USB2_COLD) },
+/* 01 */        { USB_DEVICE(USB_VID_HAUPPAUGE,     USB_PID_WINTV_NOVA_T_USB2_WARM) },
+                        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, nova_t_table);
+
+static struct dvb_usb_device_properties nova_t_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-nova-t-usb2-02.fw",
+
+        .num_adapters     = 1,
+        .adapter          = {
+                {
+                        .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .pid_filter_count = 32,
+
+                        .streaming_ctrl   = dibusb2_0_streaming_ctrl,
+                        .pid_filter       = dibusb_pid_filter,
+                        .pid_filter_ctrl  = dibusb_pid_filter_ctrl,
+                        .frontend_attach  = dibusb_dib3000mc_frontend_attach,
+                        .tuner_attach     = dibusb_dib3000mc_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                                        .stream = {
+                                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x06,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+
+                        .size_of_priv     = sizeof(struct dibusb_state),
+                }
+        },
+        .size_of_priv     = sizeof(struct dibusb_device_state),
+
+        .power_ctrl       = dibusb2_0_power_ctrl,
+        .read_mac_address = nova_t_read_mac_address,
+
+        .rc.legacy = {
+                .rc_interval      = 100,
+                .rc_map_table     = rc_map_haupp_table,
+                .rc_map_size      = ARRAY_SIZE(rc_map_haupp_table),
+                .rc_query         = nova_t_rc_query,
+        },
+
+        .i2c_algo         = &dibusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "Hauppauge WinTV-NOVA-T usb2",
+                        { &nova_t_table[0], NULL },
+                        { &nova_t_table[1], NULL },
+                },
+                { NULL },
+        }
+};
+
+static struct usb_driver nova_t_driver = {
+        .name           = "dvb_usb_nova_t_usb2",
+        .probe          = nova_t_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = nova_t_table,
+};
+
+/* module stuff */
+static int __init nova_t_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&nova_t_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit nova_t_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&nova_t_driver);
+}
+
+module_init (nova_t_module_init);
+module_exit (nova_t_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Hauppauge WinTV-NOVA-T usb2");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/opera1.c b/drivers/media/dvb/dvb-usb/opera1.c
new file mode 100644
index 00000000000..2e4fab7215f
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/opera1.c
@@ -0,0 +1,595 @@
+/* DVB USB framework compliant Linux driver for the Opera1 DVB-S Card
+*
+* Copyright (C) 2006 Mario Hlawitschka (dh1pa@amsat.org)
+* Copyright (C) 2006 Marco Gittler (g.marco@freenet.de)
+*
+*       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, version 2.
+*
+* see Documentation/dvb/README.dvb-usb for more information
+*/
+
+#define DVB_USB_LOG_PREFIX "opera"
+
+#include "dvb-usb.h"
+#include "stv0299.h"
+
+#define OPERA_READ_MSG 0
+#define OPERA_WRITE_MSG 1
+#define OPERA_I2C_TUNER 0xd1
+
+#define READ_FX2_REG_REQ  0xba
+#define READ_MAC_ADDR 0x08
+#define OPERA_WRITE_FX2 0xbb
+#define OPERA_TUNER_REQ 0xb1
+#define REG_1F_SYMBOLRATE_BYTE0 0x1f
+#define REG_20_SYMBOLRATE_BYTE1 0x20
+#define REG_21_SYMBOLRATE_BYTE2 0x21
+
+#define ADDR_B600_VOLTAGE_13V (0x02)
+#define ADDR_B601_VOLTAGE_18V (0x03)
+#define ADDR_B1A6_STREAM_CTRL (0x04)
+#define ADDR_B880_READ_REMOTE (0x05)
+
+struct opera1_state {
+        u32 last_key_pressed;
+};
+struct rc_map_opera_table {
+        u32 keycode;
+        u32 event;
+};
+
+static int dvb_usb_opera1_debug;
+module_param_named(debug, dvb_usb_opera1_debug, int, 0644);
+MODULE_PARM_DESC(debug,
+                 "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64 (or-able))."
+                 DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+
+static int opera1_xilinx_rw(struct usb_device *dev, u8 request, u16 value,
+                            u8 * data, u16 len, int flags)
+{
+        int ret;
+        u8 tmp;
+        u8 *buf;
+        unsigned int pipe = (flags == OPERA_READ_MSG) ?
+                usb_rcvctrlpipe(dev,0) : usb_sndctrlpipe(dev, 0);
+        u8 request_type = (flags == OPERA_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;
+
+        buf = kmalloc(len, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        if (flags == OPERA_WRITE_MSG)
+                memcpy(buf, data, len);
+        ret = usb_control_msg(dev, pipe, request,
+                        request_type | USB_TYPE_VENDOR, value, 0x0,
+                        buf, len, 2000);
+
+        if (request == OPERA_TUNER_REQ) {
+                tmp = buf[0];
+                if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                            OPERA_TUNER_REQ, USB_DIR_IN | USB_TYPE_VENDOR,
+                            0x01, 0x0, buf, 1, 2000) < 1 || buf[0] != 0x08) {
+                        ret = 0;
+                        goto out;
+                }
+                buf[0] = tmp;
+        }
+        if (flags == OPERA_READ_MSG)
+                memcpy(data, buf, len);
+out:
+        kfree(buf);
+        return ret;
+}
+
+/* I2C */
+
+static int opera1_usb_i2c_msgxfer(struct dvb_usb_device *dev, u16 addr,
+                                  u8 * buf, u16 len)
+{
+        int ret = 0;
+        u8 request;
+        u16 value;
+
+        if (!dev) {
+                info("no usb_device");
+                return -EINVAL;
+        }
+        if (mutex_lock_interruptible(&dev->usb_mutex) < 0)
+                return -EAGAIN;
+
+        switch (addr>>1){
+                case ADDR_B600_VOLTAGE_13V:
+                        request=0xb6;
+                        value=0x00;
+                        break;
+                case ADDR_B601_VOLTAGE_18V:
+                        request=0xb6;
+                        value=0x01;
+                        break;
+                case ADDR_B1A6_STREAM_CTRL:
+                        request=0xb1;
+                        value=0xa6;
+                        break;
+                case ADDR_B880_READ_REMOTE:
+                        request=0xb8;
+                        value=0x80;
+                        break;
+                default:
+                        request=0xb1;
+                        value=addr;
+        }
+        ret = opera1_xilinx_rw(dev->udev, request,
+                value, buf, len,
+                addr&0x01?OPERA_READ_MSG:OPERA_WRITE_MSG);
+
+        mutex_unlock(&dev->usb_mutex);
+        return ret;
+}
+
+static int opera1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                           int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i = 0, tmp = 0;
+
+        if (!d)
+                return -ENODEV;
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                if ((tmp = opera1_usb_i2c_msgxfer(d,
+                                        (msg[i].addr<<1)|(msg[i].flags&I2C_M_RD?0x01:0),
+                                        msg[i].buf,
+                                        msg[i].len
+                                        )) != msg[i].len) {
+                        break;
+                }
+                if (dvb_usb_opera1_debug & 0x10)
+                        info("sending i2c mesage %d %d", tmp, msg[i].len);
+        }
+        mutex_unlock(&d->i2c_mutex);
+        return num;
+}
+
+static u32 opera1_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm opera1_i2c_algo = {
+        .master_xfer = opera1_i2c_xfer,
+        .functionality = opera1_i2c_func,
+};
+
+static int opera1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
+{
+        static u8 command_13v[1]={0x00};
+        static u8 command_18v[1]={0x01};
+        struct i2c_msg msg[] = {
+                {.addr = ADDR_B600_VOLTAGE_13V,.flags = 0,.buf = command_13v,.len = 1},
+        };
+        struct dvb_usb_adapter *udev_adap =
+            (struct dvb_usb_adapter *)(fe->dvb->priv);
+        if (voltage == SEC_VOLTAGE_18) {
+                msg[0].addr = ADDR_B601_VOLTAGE_18V;
+                msg[0].buf = command_18v;
+        }
+        i2c_transfer(&udev_adap->dev->i2c_adap, msg, 1);
+        return 0;
+}
+
+static int opera1_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate,
+                                          u32 ratio)
+{
+        stv0299_writereg(fe, 0x13, 0x98);
+        stv0299_writereg(fe, 0x14, 0x95);
+        stv0299_writereg(fe, REG_1F_SYMBOLRATE_BYTE0, (ratio >> 16) & 0xff);
+        stv0299_writereg(fe, REG_20_SYMBOLRATE_BYTE1, (ratio >> 8) & 0xff);
+        stv0299_writereg(fe, REG_21_SYMBOLRATE_BYTE2, (ratio) & 0xf0);
+        return 0;
+
+}
+static u8 opera1_inittab[] = {
+        0x00, 0xa1,
+        0x01, 0x15,
+        0x02, 0x30,
+        0x03, 0x00,
+        0x04, 0x7d,
+        0x05, 0x05,
+        0x06, 0x02,
+        0x07, 0x00,
+        0x0b, 0x00,
+        0x0c, 0x01,
+        0x0d, 0x81,
+        0x0e, 0x44,
+        0x0f, 0x19,
+        0x10, 0x3f,
+        0x11, 0x84,
+        0x12, 0xda,
+        0x13, 0x98,
+        0x14, 0x95,
+        0x15, 0xc9,
+        0x16, 0xeb,
+        0x17, 0x00,
+        0x18, 0x19,
+        0x19, 0x8b,
+        0x1a, 0x00,
+        0x1b, 0x82,
+        0x1c, 0x7f,
+        0x1d, 0x00,
+        0x1e, 0x00,
+        REG_1F_SYMBOLRATE_BYTE0, 0x06,
+        REG_20_SYMBOLRATE_BYTE1, 0x50,
+        REG_21_SYMBOLRATE_BYTE2, 0x10,
+        0x22, 0x00,
+        0x23, 0x00,
+        0x24, 0x37,
+        0x25, 0xbc,
+        0x26, 0x00,
+        0x27, 0x00,
+        0x28, 0x00,
+        0x29, 0x1e,
+        0x2a, 0x14,
+        0x2b, 0x1f,
+        0x2c, 0x09,
+        0x2d, 0x0a,
+        0x2e, 0x00,
+        0x2f, 0x00,
+        0x30, 0x00,
+        0x31, 0x1f,
+        0x32, 0x19,
+        0x33, 0xfc,
+        0x34, 0x13,
+        0xff, 0xff,
+};
+
+static struct stv0299_config opera1_stv0299_config = {
+        .demod_address = 0xd0>>1,
+        .min_delay_ms = 100,
+        .mclk = 88000000UL,
+        .invert = 1,
+        .skip_reinit = 0,
+        .lock_output = STV0299_LOCKOUTPUT_0,
+        .volt13_op0_op1 = STV0299_VOLT13_OP0,
+        .inittab = opera1_inittab,
+        .set_symbol_rate = opera1_stv0299_set_symbol_rate,
+};
+
+static int opera1_frontend_attach(struct dvb_usb_adapter *d)
+{
+        if ((d->fe =
+             dvb_attach(stv0299_attach, &opera1_stv0299_config,
+                        &d->dev->i2c_adap)) != NULL) {
+                d->fe->ops.set_voltage = opera1_set_voltage;
+                return 0;
+        }
+        info("not attached stv0299");
+        return -EIO;
+}
+
+static int opera1_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        dvb_attach(
+                dvb_pll_attach, adap->fe, 0xc0>>1,
+                &adap->dev->i2c_adap, DVB_PLL_OPERA1
+        );
+        return 0;
+}
+
+static int opera1_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 val = onoff ? 0x01 : 0x00;
+
+        if (dvb_usb_opera1_debug)
+                info("power %s", onoff ? "on" : "off");
+        return opera1_xilinx_rw(d->udev, 0xb7, val,
+                                &val, 1, OPERA_WRITE_MSG);
+}
+
+static int opera1_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        static u8 buf_start[2] = { 0xff, 0x03 };
+        static u8 buf_stop[2] = { 0xff, 0x00 };
+        struct i2c_msg start_tuner[] = {
+                {.addr = ADDR_B1A6_STREAM_CTRL,.buf = onoff ? buf_start : buf_stop,.len = 2},
+        };
+        if (dvb_usb_opera1_debug)
+                info("streaming %s", onoff ? "on" : "off");
+        i2c_transfer(&adap->dev->i2c_adap, start_tuner, 1);
+        return 0;
+}
+
+static int opera1_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
+                             int onoff)
+{
+        u8 b_pid[3];
+        struct i2c_msg msg[] = {
+                {.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
+        };
+        if (dvb_usb_opera1_debug)
+                info("pidfilter index: %d pid: %d %s", index, pid,
+                        onoff ? "on" : "off");
+        b_pid[0] = (2 * index) + 4;
+        b_pid[1] = onoff ? (pid & 0xff) : (0x00);
+        b_pid[2] = onoff ? ((pid >> 8) & 0xff) : (0x00);
+        i2c_transfer(&adap->dev->i2c_adap, msg, 1);
+        return 0;
+}
+
+static int opera1_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
+{
+        int u = 0x04;
+        u8 b_pid[3];
+        struct i2c_msg msg[] = {
+                {.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
+        };
+        if (dvb_usb_opera1_debug)
+                info("%s hw-pidfilter", onoff ? "enable" : "disable");
+        for (; u < 0x7e; u += 2) {
+                b_pid[0] = u;
+                b_pid[1] = 0;
+                b_pid[2] = 0x80;
+                i2c_transfer(&adap->dev->i2c_adap, msg, 1);
+        }
+        return 0;
+}
+
+static struct rc_map_table rc_map_opera1_table[] = {
+        {0x5fa0, KEY_1},
+        {0x51af, KEY_2},
+        {0x5da2, KEY_3},
+        {0x41be, KEY_4},
+        {0x0bf5, KEY_5},
+        {0x43bd, KEY_6},
+        {0x47b8, KEY_7},
+        {0x49b6, KEY_8},
+        {0x05fa, KEY_9},
+        {0x45ba, KEY_0},
+        {0x09f6, KEY_CHANNELUP},        /*chanup */
+        {0x1be5, KEY_CHANNELDOWN},      /*chandown */
+        {0x5da3, KEY_VOLUMEDOWN},       /*voldown */
+        {0x5fa1, KEY_VOLUMEUP},         /*volup */
+        {0x07f8, KEY_SPACE},            /*tab */
+        {0x1fe1, KEY_OK},               /*play ok */
+        {0x1be4, KEY_ZOOM},             /*zoom */
+        {0x59a6, KEY_MUTE},             /*mute */
+        {0x5ba5, KEY_RADIO},            /*tv/f */
+        {0x19e7, KEY_RECORD},           /*rec */
+        {0x01fe, KEY_STOP},             /*Stop */
+        {0x03fd, KEY_PAUSE},            /*pause */
+        {0x03fc, KEY_SCREEN},           /*<- -> */
+        {0x07f9, KEY_CAMERA},           /*capture */
+        {0x47b9, KEY_ESC},              /*exit */
+        {0x43bc, KEY_POWER2},           /*power */
+};
+
+static int opera1_rc_query(struct dvb_usb_device *dev, u32 * event, int *state)
+{
+        struct opera1_state *opst = dev->priv;
+        u8 rcbuffer[32];
+        const u16 startmarker1 = 0x10ed;
+        const u16 startmarker2 = 0x11ec;
+        struct i2c_msg read_remote[] = {
+                {.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32},
+        };
+        int i = 0;
+        u32 send_key = 0;
+
+        if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) {
+                for (i = 0; i < 32; i++) {
+                        if (rcbuffer[i])
+                                send_key |= 1;
+                        if (i < 31)
+                                send_key = send_key << 1;
+                }
+                if (send_key & 0x8000)
+                        send_key = (send_key << 1) | (send_key >> 15 & 0x01);
+
+                if (send_key == 0xffff && opst->last_key_pressed != 0) {
+                        *state = REMOTE_KEY_REPEAT;
+                        *event = opst->last_key_pressed;
+                        return 0;
+                }
+                for (; send_key != 0;) {
+                        if (send_key >> 16 == startmarker2) {
+                                break;
+                        } else if (send_key >> 16 == startmarker1) {
+                                send_key =
+                                        (send_key & 0xfffeffff) | (startmarker1 << 16);
+                                break;
+                        } else
+                                send_key >>= 1;
+                }
+
+                if (send_key == 0)
+                        return 0;
+
+                send_key = (send_key & 0xffff) | 0x0100;
+
+                for (i = 0; i < ARRAY_SIZE(rc_map_opera1_table); i++) {
+                        if (rc5_scan(&rc_map_opera1_table[i]) == (send_key & 0xffff)) {
+                                *state = REMOTE_KEY_PRESSED;
+                                *event = rc_map_opera1_table[i].keycode;
+                                opst->last_key_pressed =
+                                        rc_map_opera1_table[i].keycode;
+                                break;
+                        }
+                        opst->last_key_pressed = 0;
+                }
+        } else
+                *state = REMOTE_NO_KEY_PRESSED;
+        return 0;
+}
+
+static struct usb_device_id opera1_table[] = {
+        {USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)},
+        {USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)},
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, opera1_table);
+
+static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
+{
+        u8 command[] = { READ_MAC_ADDR };
+        opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG);
+        opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG);
+        return 0;
+}
+static int opera1_xilinx_load_firmware(struct usb_device *dev,
+                                       const char *filename)
+{
+        const struct firmware *fw = NULL;
+        u8 *b, *p;
+        int ret = 0, i,fpgasize=40;
+        u8 testval;
+        info("start downloading fpga firmware %s",filename);
+
+        if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
+                err("did not find the firmware file. (%s) "
+                        "Please see linux/Documentation/dvb/ for more details on firmware-problems.",
+                        filename);
+                return ret;
+        } else {
+                p = kmalloc(fw->size, GFP_KERNEL);
+                opera1_xilinx_rw(dev, 0xbc, 0x00, &testval, 1, OPERA_READ_MSG);
+                if (p != NULL && testval != 0x67) {
+
+                        u8 reset = 0, fpga_command = 0;
+                        memcpy(p, fw->data, fw->size);
+                        /* clear fpga ? */
+                        opera1_xilinx_rw(dev, 0xbc, 0xaa, &fpga_command, 1,
+                                         OPERA_WRITE_MSG);
+                        for (i = 0; i < fw->size;) {
+                                if ( (fw->size - i) <fpgasize){
+                                    fpgasize=fw->size-i;
+                                }
+                                b = (u8 *) p + i;
+                                if (opera1_xilinx_rw
+                                        (dev, OPERA_WRITE_FX2, 0x0, b , fpgasize,
+                                                OPERA_WRITE_MSG) != fpgasize
+                                        ) {
+                                        err("error while transferring firmware");
+                                        ret = -EINVAL;
+                                        break;
+                                }
+                                i = i + fpgasize;
+                        }
+                        /* restart the CPU */
+                        if (ret || opera1_xilinx_rw
+                                        (dev, 0xa0, 0xe600, &reset, 1,
+                                        OPERA_WRITE_MSG) != 1) {
+                                err("could not restart the USB controller CPU.");
+                                ret = -EINVAL;
+                        }
+                }
+        }
+        kfree(p);
+        release_firmware(fw);
+        return ret;
+}
+
+static struct dvb_usb_device_properties opera1_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-opera-01.fw",
+        .size_of_priv = sizeof(struct opera1_state),
+
+        .power_ctrl = opera1_power_ctrl,
+        .i2c_algo = &opera1_i2c_algo,
+
+        .rc.legacy = {
+                .rc_map_table = rc_map_opera1_table,
+                .rc_map_size = ARRAY_SIZE(rc_map_opera1_table),
+                .rc_interval = 200,
+                .rc_query = opera1_rc_query,
+        },
+        .read_mac_address = opera1_read_mac_address,
+        .generic_bulk_ctrl_endpoint = 0x00,
+        /* parameter for the MPEG2-data transfer */
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .frontend_attach = opera1_frontend_attach,
+                        .streaming_ctrl = opera1_streaming_ctrl,
+                        .tuner_attach = opera1_tuner_attach,
+                        .caps =
+                                DVB_USB_ADAP_HAS_PID_FILTER |
+                                DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+                        .pid_filter = opera1_pid_filter,
+                        .pid_filter_ctrl = opera1_pid_filter_control,
+                        .pid_filter_count = 252,
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 10,
+                                .endpoint = 0x82,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+        .num_device_descs = 1,
+        .devices = {
+                {"Opera1 DVB-S USB2.0",
+                        {&opera1_table[0], NULL},
+                        {&opera1_table[1], NULL},
+                },
+        }
+};
+
+static int opera1_probe(struct usb_interface *intf,
+                        const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+
+        if (udev->descriptor.idProduct == USB_PID_OPERA1_WARM &&
+                udev->descriptor.idVendor == USB_VID_OPERA1 &&
+                opera1_xilinx_load_firmware(udev, "dvb-usb-opera1-fpga-01.fw") != 0
+            ) {
+                return -EINVAL;
+        }
+
+        if (0 != dvb_usb_device_init(intf, &opera1_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
+                return -EINVAL;
+        return 0;
+}
+
+static struct usb_driver opera1_driver = {
+        .name = "opera1",
+        .probe = opera1_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table = opera1_table,
+};
+
+static int __init opera1_module_init(void)
+{
+        int result = 0;
+        if ((result = usb_register(&opera1_driver))) {
+                err("usb_register failed. Error number %d", result);
+        }
+        return result;
+}
+
+static void __exit opera1_module_exit(void)
+{
+        usb_deregister(&opera1_driver);
+}
+
+module_init(opera1_module_init);
+module_exit(opera1_module_exit);
+
+MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org");
+MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de");
+MODULE_DESCRIPTION("Driver for Opera1 DVB-S device");
+MODULE_VERSION("0.1");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/technisat-usb2.c b/drivers/media/dvb/dvb-usb/technisat-usb2.c
new file mode 100644
index 00000000000..473b95ed4d5
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/technisat-usb2.c
@@ -0,0 +1,805 @@
+/*
+ * Linux driver for Technisat DVB-S/S2 USB 2.0 device
+ *
+ * Copyright (C) 2010 Patrick Boettcher,
+ *                    Kernel Labs Inc. PO Box 745, St James, NY 11780
+ *
+ * Development was sponsored by Technisat Digital UK Limited, whose
+ * registered office is Witan Gate House 500 - 600 Witan Gate West,
+ * Milton Keynes, MK9 1SH
+ *
+ * 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.
+ *
+ *
+ * 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 PROGRAM IS PROVIDED "AS IS" AND BOTH THE COPYRIGHT HOLDER AND
+ * TECHNISAT DIGITAL UK LTD DISCLAIM ALL WARRANTIES WITH REGARD TO
+ * THIS PROGRAM INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY OR
+ * FITNESS FOR A PARTICULAR PURPOSE.  NEITHER THE COPYRIGHT HOLDER
+ * NOR TECHNISAT DIGITAL UK LIMITED SHALL BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+ * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS PROGRAM. See the
+ * GNU General Public License for more details.
+ */
+
+#define DVB_USB_LOG_PREFIX "technisat-usb2"
+#include "dvb-usb.h"
+
+#include "stv6110x.h"
+#include "stv090x.h"
+
+/* module parameters */
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug,
+                "set debugging level (bit-mask: 1=info,2=eeprom,4=i2c,8=rc)." \
+                DVB_USB_DEBUG_STATUS);
+
+/* disables all LED control command and
+ * also does not start the signal polling thread */
+static int disable_led_control;
+module_param(disable_led_control, int, 0444);
+MODULE_PARM_DESC(disable_led_control,
+                "disable LED control of the device "
+                "(default: 0 - LED control is active).");
+
+/* device private data */
+struct technisat_usb2_state {
+        struct dvb_usb_device *dev;
+        struct delayed_work green_led_work;
+        u8 power_state;
+
+        u16 last_scan_code;
+};
+
+/* debug print helpers */
+#define deb_info(args...)    dprintk(debug, 0x01, args)
+#define deb_eeprom(args...)  dprintk(debug, 0x02, args)
+#define deb_i2c(args...)     dprintk(debug, 0x04, args)
+#define deb_rc(args...)      dprintk(debug, 0x08, args)
+
+/* vendor requests */
+#define SET_IFCLK_TO_EXTERNAL_TSCLK_VENDOR_REQUEST 0xB3
+#define SET_FRONT_END_RESET_VENDOR_REQUEST         0xB4
+#define GET_VERSION_INFO_VENDOR_REQUEST            0xB5
+#define SET_GREEN_LED_VENDOR_REQUEST               0xB6
+#define SET_RED_LED_VENDOR_REQUEST                 0xB7
+#define GET_IR_DATA_VENDOR_REQUEST                 0xB8
+#define SET_LED_TIMER_DIVIDER_VENDOR_REQUEST       0xB9
+#define SET_USB_REENUMERATION                      0xBA
+
+/* i2c-access methods */
+#define I2C_SPEED_100KHZ_BIT 0x40
+
+#define I2C_STATUS_NAK 7
+#define I2C_STATUS_OK 8
+
+static int technisat_usb2_i2c_access(struct usb_device *udev,
+                u8 device_addr, u8 *tx, u8 txlen, u8 *rx, u8 rxlen)
+{
+        u8 b[64];
+        int ret, actual_length;
+
+        deb_i2c("i2c-access: %02x, tx: ", device_addr);
+        debug_dump(tx, txlen, deb_i2c);
+        deb_i2c(" ");
+
+        if (txlen > 62) {
+                err("i2c TX buffer can't exceed 62 bytes (dev 0x%02x)",
+                                device_addr);
+                txlen = 62;
+        }
+        if (rxlen > 62) {
+                err("i2c RX buffer can't exceed 62 bytes (dev 0x%02x)",
+                                device_addr);
+                txlen = 62;
+        }
+
+        b[0] = I2C_SPEED_100KHZ_BIT;
+        b[1] = device_addr << 1;
+
+        if (rx != NULL) {
+                b[0] |= rxlen;
+                b[1] |= 1;
+        }
+
+        memcpy(&b[2], tx, txlen);
+        ret = usb_bulk_msg(udev,
+                        usb_sndbulkpipe(udev, 0x01),
+                        b, 2 + txlen,
+                        NULL, 1000);
+
+        if (ret < 0) {
+                err("i2c-error: out failed %02x = %d", device_addr, ret);
+                return -ENODEV;
+        }
+
+        ret = usb_bulk_msg(udev,
+                        usb_rcvbulkpipe(udev, 0x01),
+                        b, 64, &actual_length, 1000);
+        if (ret < 0) {
+                err("i2c-error: in failed %02x = %d", device_addr, ret);
+                return -ENODEV;
+        }
+
+        if (b[0] != I2C_STATUS_OK) {
+                err("i2c-error: %02x = %d", device_addr, b[0]);
+                /* handle tuner-i2c-nak */
+                if (!(b[0] == I2C_STATUS_NAK &&
+                                device_addr == 0x60
+                                /* && device_is_technisat_usb2 */))
+                        return -ENODEV;
+        }
+
+        deb_i2c("status: %d, ", b[0]);
+
+        if (rx != NULL) {
+                memcpy(rx, &b[2], rxlen);
+
+                deb_i2c("rx (%d): ", rxlen);
+                debug_dump(rx, rxlen, deb_i2c);
+        }
+
+        deb_i2c("\n");
+
+        return 0;
+}
+
+static int technisat_usb2_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
+                                int num)
+{
+        int ret = 0, i;
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+
+        /* Ensure nobody else hits the i2c bus while we're sending our
+           sequence of messages, (such as the remote control thread) */
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                if (i+1 < num && msg[i+1].flags & I2C_M_RD) {
+                        ret = technisat_usb2_i2c_access(d->udev, msg[i+1].addr,
+                                                msg[i].buf, msg[i].len,
+                                                msg[i+1].buf, msg[i+1].len);
+                        if (ret != 0)
+                                break;
+                        i++;
+                } else {
+                        ret = technisat_usb2_i2c_access(d->udev, msg[i].addr,
+                                                msg[i].buf, msg[i].len,
+                                                NULL, 0);
+                        if (ret != 0)
+                                break;
+                }
+        }
+
+        if (ret == 0)
+                ret = i;
+
+        mutex_unlock(&d->i2c_mutex);
+
+        return ret;
+}
+
+static u32 technisat_usb2_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm technisat_usb2_i2c_algo = {
+        .master_xfer   = technisat_usb2_i2c_xfer,
+        .functionality = technisat_usb2_i2c_func,
+};
+
+#if 0
+static void technisat_usb2_frontend_reset(struct usb_device *udev)
+{
+        usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                        SET_FRONT_END_RESET_VENDOR_REQUEST,
+                        USB_TYPE_VENDOR | USB_DIR_OUT,
+                        10, 0,
+                        NULL, 0, 500);
+}
+#endif
+
+/* LED control */
+enum technisat_usb2_led_state {
+        LED_OFF,
+        LED_BLINK,
+        LED_ON,
+        LED_UNDEFINED
+};
+
+static int technisat_usb2_set_led(struct dvb_usb_device *d, int red, enum technisat_usb2_led_state state)
+{
+        int ret;
+
+        u8 led[8] = {
+                red ? SET_RED_LED_VENDOR_REQUEST : SET_GREEN_LED_VENDOR_REQUEST,
+                0
+        };
+
+        if (disable_led_control && state != LED_OFF)
+                return 0;
+
+        switch (state) {
+        case LED_ON:
+                led[1] = 0x82;
+                break;
+        case LED_BLINK:
+                led[1] = 0x82;
+                if (red) {
+                        led[2] = 0x02;
+                        led[3] = 10;
+                        led[4] = 10;
+                } else {
+                        led[2] = 0xff;
+                        led[3] = 50;
+                        led[4] = 50;
+                }
+                led[5] = 1;
+                break;
+
+        default:
+        case LED_OFF:
+                led[1] = 0x80;
+                break;
+        }
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                red ? SET_RED_LED_VENDOR_REQUEST : SET_GREEN_LED_VENDOR_REQUEST,
+                USB_TYPE_VENDOR | USB_DIR_OUT,
+                0, 0,
+                led, sizeof(led), 500);
+
+        mutex_unlock(&d->i2c_mutex);
+        return ret;
+}
+
+static int technisat_usb2_set_led_timer(struct dvb_usb_device *d, u8 red, u8 green)
+{
+        int ret;
+        u8 b = 0;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                SET_LED_TIMER_DIVIDER_VENDOR_REQUEST,
+                USB_TYPE_VENDOR | USB_DIR_OUT,
+                (red << 8) | green, 0,
+                &b, 1, 500);
+
+        mutex_unlock(&d->i2c_mutex);
+
+        return ret;
+}
+
+static void technisat_usb2_green_led_control(struct work_struct *work)
+{
+        struct technisat_usb2_state *state =
+                container_of(work, struct technisat_usb2_state, green_led_work.work);
+        struct dvb_frontend *fe = state->dev->adapter[0].fe;
+
+        if (state->power_state == 0)
+                goto schedule;
+
+        if (fe != NULL) {
+                enum fe_status status;
+
+                if (fe->ops.read_status(fe, &status) != 0)
+                        goto schedule;
+
+                if (status & FE_HAS_LOCK) {
+                        u32 ber;
+
+                        if (fe->ops.read_ber(fe, &ber) != 0)
+                                goto schedule;
+
+                        if (ber > 1000)
+                                technisat_usb2_set_led(state->dev, 0, LED_BLINK);
+                        else
+                                technisat_usb2_set_led(state->dev, 0, LED_ON);
+                } else
+                        technisat_usb2_set_led(state->dev, 0, LED_OFF);
+        }
+
+schedule:
+        schedule_delayed_work(&state->green_led_work,
+                        msecs_to_jiffies(500));
+}
+
+/* method to find out whether the firmware has to be downloaded or not */
+static int technisat_usb2_identify_state(struct usb_device *udev,
+                struct dvb_usb_device_properties *props,
+                struct dvb_usb_device_description **desc, int *cold)
+{
+        int ret;
+        u8 version[3];
+
+        /* first select the interface */
+        if (usb_set_interface(udev, 0, 1) != 0)
+                err("could not set alternate setting to 0");
+        else
+                info("set alternate setting");
+
+        *cold = 0; /* by default do not download a firmware - just in case something is wrong */
+
+        ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                GET_VERSION_INFO_VENDOR_REQUEST,
+                USB_TYPE_VENDOR | USB_DIR_IN,
+                0, 0,
+                version, sizeof(version), 500);
+
+        if (ret < 0)
+                *cold = 1;
+        else {
+                info("firmware version: %d.%d", version[1], version[2]);
+                *cold = 0;
+        }
+
+        return 0;
+}
+
+/* power control */
+static int technisat_usb2_power_ctrl(struct dvb_usb_device *d, int level)
+{
+        struct technisat_usb2_state *state = d->priv;
+
+        state->power_state = level;
+
+        if (disable_led_control)
+                return 0;
+
+        /* green led is turned off in any case - will be turned on when tuning */
+        technisat_usb2_set_led(d, 0, LED_OFF);
+        /* red led is turned on all the time */
+        technisat_usb2_set_led(d, 1, LED_ON);
+        return 0;
+}
+
+/* mac address reading - from the eeprom */
+#if 0
+static void technisat_usb2_eeprom_dump(struct dvb_usb_device *d)
+{
+        u8 reg;
+        u8 b[16];
+        int i, j;
+
+        /* full EEPROM dump */
+        for (j = 0; j < 256 * 4; j += 16) {
+                reg = j;
+                if (technisat_usb2_i2c_access(d->udev, 0x50 + j / 256, &reg, 1, b, 16) != 0)
+                        break;
+
+                deb_eeprom("EEPROM: %01x%02x: ", j / 256, reg);
+                for (i = 0; i < 16; i++)
+                        deb_eeprom("%02x ", b[i]);
+                deb_eeprom("\n");
+        }
+}
+#endif
+
+static u8 technisat_usb2_calc_lrc(const u8 *b, u16 length)
+{
+        u8 lrc = 0;
+        while (--length)
+                lrc ^= *b++;
+        return lrc;
+}
+
+static int technisat_usb2_eeprom_lrc_read(struct dvb_usb_device *d,
+        u16 offset, u8 *b, u16 length, u8 tries)
+{
+        u8 bo = offset & 0xff;
+        struct i2c_msg msg[] = {
+                {
+                        .addr = 0x50 | ((offset >> 8) & 0x3),
+                        .buf = &bo,
+                        .len = 1
+                }, {
+                        .addr = 0x50 | ((offset >> 8) & 0x3),
+                        .flags  = I2C_M_RD,
+                        .buf = b,
+                        .len = length
+                }
+        };
+
+        while (tries--) {
+                int status;
+
+                if (i2c_transfer(&d->i2c_adap, msg, 2) != 2)
+                        break;
+
+                status =
+                        technisat_usb2_calc_lrc(b, length - 1) == b[length - 1];
+
+                if (status)
+                        return 0;
+        }
+
+        return -EREMOTEIO;
+}
+
+#define EEPROM_MAC_START 0x3f8
+#define EEPROM_MAC_TOTAL 8
+static int technisat_usb2_read_mac_address(struct dvb_usb_device *d,
+                u8 mac[])
+{
+        u8 buf[EEPROM_MAC_TOTAL];
+
+        if (technisat_usb2_eeprom_lrc_read(d, EEPROM_MAC_START,
+                                buf, EEPROM_MAC_TOTAL, 4) != 0)
+                return -ENODEV;
+
+        memcpy(mac, buf, 6);
+        return 0;
+}
+
+/* frontend attach */
+static int technisat_usb2_set_voltage(struct dvb_frontend *fe,
+                fe_sec_voltage_t voltage)
+{
+        int i;
+        u8 gpio[3] = { 0 }; /* 0 = 2, 1 = 3, 2 = 4 */
+
+        gpio[2] = 1; /* high - voltage ? */
+
+        switch (voltage) {
+        case SEC_VOLTAGE_13:
+                gpio[0] = 1;
+                break;
+        case SEC_VOLTAGE_18:
+                gpio[0] = 1;
+                gpio[1] = 1;
+                break;
+        default:
+        case SEC_VOLTAGE_OFF:
+                break;
+        }
+
+        for (i = 0; i < 3; i++)
+                if (stv090x_set_gpio(fe, i+2, 0, gpio[i], 0) != 0)
+                        return -EREMOTEIO;
+        return 0;
+}
+
+static struct stv090x_config technisat_usb2_stv090x_config = {
+        .device         = STV0903,
+        .demod_mode     = STV090x_SINGLE,
+        .clk_mode       = STV090x_CLK_EXT,
+
+        .xtal           = 8000000,
+        .address        = 0x68,
+
+        .ts1_mode       = STV090x_TSMODE_DVBCI,
+        .ts1_clk        = 13400000,
+        .ts1_tei        = 1,
+
+        .repeater_level = STV090x_RPTLEVEL_64,
+
+        .tuner_bbgain   = 6,
+};
+
+static struct stv6110x_config technisat_usb2_stv6110x_config = {
+        .addr           = 0x60,
+        .refclk         = 16000000,
+        .clk_div        = 2,
+};
+
+static int technisat_usb2_frontend_attach(struct dvb_usb_adapter *a)
+{
+        struct usb_device *udev = a->dev->udev;
+        int ret;
+
+        a->fe = dvb_attach(stv090x_attach, &technisat_usb2_stv090x_config,
+                        &a->dev->i2c_adap, STV090x_DEMODULATOR_0);
+
+        if (a->fe) {
+                struct stv6110x_devctl *ctl;
+
+                ctl = dvb_attach(stv6110x_attach,
+                                a->fe,
+                                &technisat_usb2_stv6110x_config,
+                                &a->dev->i2c_adap);
+
+                if (ctl) {
+                        technisat_usb2_stv090x_config.tuner_init          = ctl->tuner_init;
+                        technisat_usb2_stv090x_config.tuner_sleep         = ctl->tuner_sleep;
+                        technisat_usb2_stv090x_config.tuner_set_mode      = ctl->tuner_set_mode;
+                        technisat_usb2_stv090x_config.tuner_set_frequency = ctl->tuner_set_frequency;
+                        technisat_usb2_stv090x_config.tuner_get_frequency = ctl->tuner_get_frequency;
+                        technisat_usb2_stv090x_config.tuner_set_bandwidth = ctl->tuner_set_bandwidth;
+                        technisat_usb2_stv090x_config.tuner_get_bandwidth = ctl->tuner_get_bandwidth;
+                        technisat_usb2_stv090x_config.tuner_set_bbgain    = ctl->tuner_set_bbgain;
+                        technisat_usb2_stv090x_config.tuner_get_bbgain    = ctl->tuner_get_bbgain;
+                        technisat_usb2_stv090x_config.tuner_set_refclk    = ctl->tuner_set_refclk;
+                        technisat_usb2_stv090x_config.tuner_get_status    = ctl->tuner_get_status;
+
+                        /* call the init function once to initialize
+                           tuner's clock output divider and demod's
+                           master clock */
+                        if (a->fe->ops.init)
+                                a->fe->ops.init(a->fe);
+
+                        if (mutex_lock_interruptible(&a->dev->i2c_mutex) < 0)
+                                return -EAGAIN;
+
+                        ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                        SET_IFCLK_TO_EXTERNAL_TSCLK_VENDOR_REQUEST,
+                                        USB_TYPE_VENDOR | USB_DIR_OUT,
+                                        0, 0,
+                                        NULL, 0, 500);
+                        mutex_unlock(&a->dev->i2c_mutex);
+
+                        if (ret != 0)
+                                err("could not set IF_CLK to external");
+
+                        a->fe->ops.set_voltage = technisat_usb2_set_voltage;
+
+                        /* if everything was successful assign a nice name to the frontend */
+                        strlcpy(a->fe->ops.info.name, a->dev->desc->name,
+                                        sizeof(a->fe->ops.info.name));
+                } else {
+                        dvb_frontend_detach(a->fe);
+                        a->fe = NULL;
+                }
+        }
+
+        technisat_usb2_set_led_timer(a->dev, 1, 1);
+
+        return a->fe == NULL ? -ENODEV : 0;
+}
+
+/* Remote control */
+
+/* the device is giving providing raw IR-signals to the host mapping
+ * it only to one remote control is just the default implementation
+ */
+#define NOMINAL_IR_BIT_TRANSITION_TIME_US 889
+#define NOMINAL_IR_BIT_TIME_US (2 * NOMINAL_IR_BIT_TRANSITION_TIME_US)
+
+#define FIRMWARE_CLOCK_TICK 83333
+#define FIRMWARE_CLOCK_DIVISOR 256
+
+#define IR_PERCENT_TOLERANCE 15
+
+#define NOMINAL_IR_BIT_TRANSITION_TICKS ((NOMINAL_IR_BIT_TRANSITION_TIME_US * 1000 * 1000) / FIRMWARE_CLOCK_TICK)
+#define NOMINAL_IR_BIT_TRANSITION_TICK_COUNT (NOMINAL_IR_BIT_TRANSITION_TICKS / FIRMWARE_CLOCK_DIVISOR)
+
+#define NOMINAL_IR_BIT_TIME_TICKS ((NOMINAL_IR_BIT_TIME_US * 1000 * 1000) / FIRMWARE_CLOCK_TICK)
+#define NOMINAL_IR_BIT_TIME_TICK_COUNT (NOMINAL_IR_BIT_TIME_TICKS / FIRMWARE_CLOCK_DIVISOR)
+
+#define MINIMUM_IR_BIT_TRANSITION_TICK_COUNT (NOMINAL_IR_BIT_TRANSITION_TICK_COUNT - ((NOMINAL_IR_BIT_TRANSITION_TICK_COUNT * IR_PERCENT_TOLERANCE) / 100))
+#define MAXIMUM_IR_BIT_TRANSITION_TICK_COUNT (NOMINAL_IR_BIT_TRANSITION_TICK_COUNT + ((NOMINAL_IR_BIT_TRANSITION_TICK_COUNT * IR_PERCENT_TOLERANCE) / 100))
+
+#define MINIMUM_IR_BIT_TIME_TICK_COUNT (NOMINAL_IR_BIT_TIME_TICK_COUNT - ((NOMINAL_IR_BIT_TIME_TICK_COUNT * IR_PERCENT_TOLERANCE) / 100))
+#define MAXIMUM_IR_BIT_TIME_TICK_COUNT (NOMINAL_IR_BIT_TIME_TICK_COUNT + ((NOMINAL_IR_BIT_TIME_TICK_COUNT * IR_PERCENT_TOLERANCE) / 100))
+
+static int technisat_usb2_get_ir(struct dvb_usb_device *d)
+{
+        u8 buf[62], *b;
+        int ret;
+        struct ir_raw_event ev;
+
+        buf[0] = GET_IR_DATA_VENDOR_REQUEST;
+        buf[1] = 0x08;
+        buf[2] = 0x8f;
+        buf[3] = MINIMUM_IR_BIT_TRANSITION_TICK_COUNT;
+        buf[4] = MAXIMUM_IR_BIT_TIME_TICK_COUNT;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+        ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                        GET_IR_DATA_VENDOR_REQUEST,
+                        USB_TYPE_VENDOR | USB_DIR_OUT,
+                        0, 0,
+                        buf, 5, 500);
+        if (ret < 0)
+                goto unlock;
+
+        buf[1] = 0;
+        buf[2] = 0;
+        ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
+                        GET_IR_DATA_VENDOR_REQUEST,
+                        USB_TYPE_VENDOR | USB_DIR_IN,
+                        0x8080, 0,
+                        buf, sizeof(buf), 500);
+
+unlock:
+        mutex_unlock(&d->i2c_mutex);
+
+        if (ret < 0)
+                return ret;
+
+        if (ret == 1)
+                return 0; /* no key pressed */
+
+        /* decoding */
+        b = buf+1;
+
+#if 0
+        deb_rc("RC: %d ", ret);
+        debug_dump(b, ret, deb_rc);
+#endif
+
+        ev.pulse = 0;
+        while (1) {
+                ev.pulse = !ev.pulse;
+                ev.duration = (*b * FIRMWARE_CLOCK_DIVISOR * FIRMWARE_CLOCK_TICK) / 1000;
+                ir_raw_event_store(d->rc_dev, &ev);
+
+                b++;
+                if (*b == 0xff) {
+                        ev.pulse = 0;
+                        ev.duration = 888888*2;
+                        ir_raw_event_store(d->rc_dev, &ev);
+                        break;
+                }
+        }
+
+        ir_raw_event_handle(d->rc_dev);
+
+        return 1;
+}
+
+static int technisat_usb2_rc_query(struct dvb_usb_device *d)
+{
+        int ret = technisat_usb2_get_ir(d);
+
+        if (ret < 0)
+                return ret;
+
+        if (ret == 0)
+                return 0;
+
+        if (!disable_led_control)
+                technisat_usb2_set_led(d, 1, LED_BLINK);
+
+        return 0;
+}
+
+/* DVB-USB and USB stuff follows */
+static struct usb_device_id technisat_usb2_id_table[] = {
+        { USB_DEVICE(USB_VID_TECHNISAT, USB_PID_TECHNISAT_USB2_DVB_S2) },
+        { 0 }           /* Terminating entry */
+};
+
+/* device description */
+static struct dvb_usb_device_properties technisat_usb2_devices = {
+        .caps              = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl          = CYPRESS_FX2,
+
+        .identify_state    = technisat_usb2_identify_state,
+        .firmware          = "dvb-usb-SkyStar_USB_HD_FW_v17_63.HEX.fw",
+
+        .size_of_priv      = sizeof(struct technisat_usb2_state),
+
+        .i2c_algo          = &technisat_usb2_i2c_algo,
+
+        .power_ctrl        = technisat_usb2_power_ctrl,
+        .read_mac_address  = technisat_usb2_read_mac_address,
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .frontend_attach  = technisat_usb2_frontend_attach,
+
+                        .stream = {
+                                .type = USB_ISOC,
+                                .count = 8,
+                                .endpoint = 0x2,
+                                .u = {
+                                        .isoc = {
+                                                .framesperurb = 32,
+                                                .framesize = 2048,
+                                                .interval = 3,
+                                        }
+                                }
+                        },
+
+                        .size_of_priv = 0,
+                },
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "Technisat SkyStar USB HD (DVB-S/S2)",
+                        { &technisat_usb2_id_table[0], NULL },
+                        { NULL },
+                },
+        },
+
+        .rc.core = {
+                .rc_interval = 100,
+                .rc_codes    = RC_MAP_TECHNISAT_USB2,
+                .module_name = "technisat-usb2",
+                .rc_query    = technisat_usb2_rc_query,
+                .allowed_protos = RC_TYPE_ALL,
+                .driver_type    = RC_DRIVER_IR_RAW,
+        }
+};
+
+static int technisat_usb2_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        struct dvb_usb_device *dev;
+
+        if (dvb_usb_device_init(intf, &technisat_usb2_devices, THIS_MODULE,
+                                &dev, adapter_nr) != 0)
+                return -ENODEV;
+
+        if (dev) {
+                struct technisat_usb2_state *state = dev->priv;
+                state->dev = dev;
+
+                if (!disable_led_control) {
+                        INIT_DELAYED_WORK(&state->green_led_work,
+                                        technisat_usb2_green_led_control);
+                        schedule_delayed_work(&state->green_led_work,
+                                        msecs_to_jiffies(500));
+                }
+        }
+
+        return 0;
+}
+
+static void technisat_usb2_disconnect(struct usb_interface *intf)
+{
+        struct dvb_usb_device *dev = usb_get_intfdata(intf);
+
+        /* work and stuff was only created when the device is is hot-state */
+        if (dev != NULL) {
+                struct technisat_usb2_state *state = dev->priv;
+                if (state != NULL)
+                        cancel_delayed_work_sync(&state->green_led_work);
+        }
+
+        dvb_usb_device_exit(intf);
+}
+
+static struct usb_driver technisat_usb2_driver = {
+        .name       = "dvb_usb_technisat_usb2",
+        .probe      = technisat_usb2_probe,
+        .disconnect = technisat_usb2_disconnect,
+        .id_table   = technisat_usb2_id_table,
+};
+
+/* module stuff */
+static int __init technisat_usb2_module_init(void)
+{
+        int result = usb_register(&technisat_usb2_driver);
+        if (result) {
+                err("usb_register failed. Code %d", result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit technisat_usb2_module_exit(void)
+{
+        usb_deregister(&technisat_usb2_driver);
+}
+
+module_init(technisat_usb2_module_init);
+module_exit(technisat_usb2_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <pboettcher@kernellabs.com>");
+MODULE_DESCRIPTION("Driver for Technisat DVB-S/S2 USB 2.0 device");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/ttusb2.c b/drivers/media/dvb/dvb-usb/ttusb2.c
new file mode 100644
index 00000000000..0d4709ff9cb
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/ttusb2.c
@@ -0,0 +1,453 @@
+/* DVB USB compliant linux driver for Technotrend DVB USB boxes and clones
+ * (e.g. Pinnacle 400e DVB-S USB2.0).
+ *
+ * The Pinnacle 400e uses the same protocol as the Technotrend USB1.1 boxes.
+ *
+ * TDA8263 + TDA10086
+ *
+ * I2C addresses:
+ * 0x08 - LNBP21PD   - LNB power supply
+ * 0x0e - TDA10086   - Demodulator
+ * 0x50 - FX2 eeprom
+ * 0x60 - TDA8263    - Tuner
+ * 0x78 ???
+ *
+ * Copyright (c) 2002 Holger Waechtler <holger@convergence.de>
+ * Copyright (c) 2003 Felix Domke <tmbinc@elitedvb.net>
+ * Copyright (C) 2005-6 Patrick Boettcher <pb@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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#define DVB_USB_LOG_PREFIX "ttusb2"
+#include "dvb-usb.h"
+
+#include "ttusb2.h"
+
+#include "tda826x.h"
+#include "tda10086.h"
+#include "tda1002x.h"
+#include "tda827x.h"
+#include "lnbp21.h"
+
+/* debug */
+static int dvb_usb_ttusb2_debug;
+#define deb_info(args...)   dprintk(dvb_usb_ttusb2_debug,0x01,args)
+module_param_named(debug,dvb_usb_ttusb2_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+struct ttusb2_state {
+        u8 id;
+        u16 last_rc_key;
+};
+
+static int ttusb2_msg(struct dvb_usb_device *d, u8 cmd,
+                u8 *wbuf, int wlen, u8 *rbuf, int rlen)
+{
+        struct ttusb2_state *st = d->priv;
+        u8 s[wlen+4],r[64] = { 0 };
+        int ret = 0;
+
+        memset(s,0,wlen+4);
+
+        s[0] = 0xaa;
+        s[1] = ++st->id;
+        s[2] = cmd;
+        s[3] = wlen;
+        memcpy(&s[4],wbuf,wlen);
+
+        ret = dvb_usb_generic_rw(d, s, wlen+4, r, 64, 0);
+
+        if (ret  != 0 ||
+                r[0] != 0x55 ||
+                r[1] != s[1] ||
+                r[2] != cmd ||
+                (rlen > 0 && r[3] != rlen)) {
+                warn("there might have been an error during control message transfer. (rlen = %d, was %d)",rlen,r[3]);
+                return -EIO;
+        }
+
+        if (rlen > 0)
+                memcpy(rbuf, &r[4], rlen);
+
+        return 0;
+}
+
+static int ttusb2_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        static u8 obuf[60], ibuf[60];
+        int i,read;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        if (num > 2)
+                warn("more than 2 i2c messages at a time is not handled yet. TODO.");
+
+        for (i = 0; i < num; i++) {
+                read = i+1 < num && (msg[i+1].flags & I2C_M_RD);
+
+                obuf[0] = (msg[i].addr << 1) | read;
+                obuf[1] = msg[i].len;
+
+                /* read request */
+                if (read)
+                        obuf[2] = msg[i+1].len;
+                else
+                        obuf[2] = 0;
+
+                memcpy(&obuf[3],msg[i].buf,msg[i].len);
+
+                if (ttusb2_msg(d, CMD_I2C_XFER, obuf, msg[i].len+3, ibuf, obuf[2] + 3) < 0) {
+                        err("i2c transfer failed.");
+                        break;
+                }
+
+                if (read) {
+                        memcpy(msg[i+1].buf,&ibuf[3],msg[i+1].len);
+                        i++;
+                }
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+static u32 ttusb2_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm ttusb2_i2c_algo = {
+        .master_xfer   = ttusb2_i2c_xfer,
+        .functionality = ttusb2_i2c_func,
+};
+
+/* command to poll IR receiver (copied from pctv452e.c) */
+#define CMD_GET_IR_CODE     0x1b
+
+/* IR */
+static int tt3650_rc_query(struct dvb_usb_device *d)
+{
+        int ret;
+        u8 rx[9]; /* A CMD_GET_IR_CODE reply is 9 bytes long */
+        struct ttusb2_state *st = d->priv;
+        ret = ttusb2_msg(d, CMD_GET_IR_CODE, NULL, 0, rx, sizeof(rx));
+        if (ret != 0)
+                return ret;
+
+        if (rx[8] & 0x01) {
+                /* got a "press" event */
+                st->last_rc_key = (rx[3] << 8) | rx[2];
+                deb_info("%s: cmd=0x%02x sys=0x%02x\n", __func__, rx[2], rx[3]);
+                rc_keydown(d->rc_dev, st->last_rc_key, 0);
+        } else if (st->last_rc_key) {
+                rc_keyup(d->rc_dev);
+                st->last_rc_key = 0;
+        }
+
+        return 0;
+}
+
+
+/* Callbacks for DVB USB */
+static int ttusb2_identify_state (struct usb_device *udev, struct
+                dvb_usb_device_properties *props, struct dvb_usb_device_description **desc,
+                int *cold)
+{
+        *cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0;
+        return 0;
+}
+
+static int ttusb2_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 b = onoff;
+        ttusb2_msg(d, CMD_POWER, &b, 0, NULL, 0);
+        return ttusb2_msg(d, CMD_POWER, &b, 1, NULL, 0);
+}
+
+
+static struct tda10086_config tda10086_config = {
+        .demod_address = 0x0e,
+        .invert = 0,
+        .diseqc_tone = 1,
+        .xtal_freq = TDA10086_XTAL_16M,
+};
+
+static struct tda10023_config tda10023_config = {
+        .demod_address = 0x0c,
+        .invert = 0,
+        .xtal = 16000000,
+        .pll_m = 11,
+        .pll_p = 3,
+        .pll_n = 1,
+        .deltaf = 0xa511,
+};
+
+static int ttusb2_frontend_tda10086_attach(struct dvb_usb_adapter *adap)
+{
+        if (usb_set_interface(adap->dev->udev,0,3) < 0)
+                err("set interface to alts=3 failed");
+
+        if ((adap->fe = dvb_attach(tda10086_attach, &tda10086_config, &adap->dev->i2c_adap)) == NULL) {
+                deb_info("TDA10086 attach failed\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int ttusb2_frontend_tda10023_attach(struct dvb_usb_adapter *adap)
+{
+        if (usb_set_interface(adap->dev->udev, 0, 3) < 0)
+                err("set interface to alts=3 failed");
+        if ((adap->fe = dvb_attach(tda10023_attach, &tda10023_config, &adap->dev->i2c_adap, 0x48)) == NULL) {
+                deb_info("TDA10023 attach failed\n");
+                return -ENODEV;
+        }
+        return 0;
+}
+
+static int ttusb2_tuner_tda827x_attach(struct dvb_usb_adapter *adap)
+{
+        if (dvb_attach(tda827x_attach, adap->fe, 0x61, &adap->dev->i2c_adap, NULL) == NULL) {
+                printk(KERN_ERR "%s: No tda827x found!\n", __func__);
+                return -ENODEV;
+        }
+        return 0;
+}
+
+static int ttusb2_tuner_tda826x_attach(struct dvb_usb_adapter *adap)
+{
+        if (dvb_attach(tda826x_attach, adap->fe, 0x60, &adap->dev->i2c_adap, 0) == NULL) {
+                deb_info("TDA8263 attach failed\n");
+                return -ENODEV;
+        }
+
+        if (dvb_attach(lnbp21_attach, adap->fe, &adap->dev->i2c_adap, 0, 0) == NULL) {
+                deb_info("LNBP21 attach failed\n");
+                return -ENODEV;
+        }
+        return 0;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties ttusb2_properties;
+static struct dvb_usb_device_properties ttusb2_properties_s2400;
+static struct dvb_usb_device_properties ttusb2_properties_ct3650;
+
+static int ttusb2_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        if (0 == dvb_usb_device_init(intf, &ttusb2_properties,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &ttusb2_properties_s2400,
+                                     THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, &ttusb2_properties_ct3650,
+                                     THIS_MODULE, NULL, adapter_nr))
+                return 0;
+        return -ENODEV;
+}
+
+static struct usb_device_id ttusb2_table [] = {
+        { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_400E) },
+        { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_450E) },
+        { USB_DEVICE(USB_VID_TECHNOTREND,
+                USB_PID_TECHNOTREND_CONNECT_S2400) },
+        { USB_DEVICE(USB_VID_TECHNOTREND,
+                USB_PID_TECHNOTREND_CONNECT_CT3650) },
+        {}              /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, ttusb2_table);
+
+static struct dvb_usb_device_properties ttusb2_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-pctv-400e-01.fw",
+
+        .size_of_priv = sizeof(struct ttusb2_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = NULL, // ttusb2_streaming_ctrl,
+
+                        .frontend_attach  = ttusb2_frontend_tda10086_attach,
+                        .tuner_attach     = ttusb2_tuner_tda826x_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_ISOC,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .isoc = {
+                                                .framesperurb = 4,
+                                                .framesize = 940,
+                                                .interval = 1,
+                                        }
+                                }
+                        }
+                }
+        },
+
+        .power_ctrl       = ttusb2_power_ctrl,
+        .identify_state   = ttusb2_identify_state,
+
+        .i2c_algo         = &ttusb2_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 2,
+        .devices = {
+                {   "Pinnacle 400e DVB-S USB2.0",
+                        { &ttusb2_table[0], NULL },
+                        { NULL },
+                },
+                {   "Pinnacle 450e DVB-S USB2.0",
+                        { &ttusb2_table[1], NULL },
+                        { NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties ttusb2_properties_s2400 = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-tt-s2400-01.fw",
+
+        .size_of_priv = sizeof(struct ttusb2_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = NULL,
+
+                        .frontend_attach  = ttusb2_frontend_tda10086_attach,
+                        .tuner_attach     = ttusb2_tuner_tda826x_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_ISOC,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .isoc = {
+                                                .framesperurb = 4,
+                                                .framesize = 940,
+                                                .interval = 1,
+                                        }
+                                }
+                        }
+                }
+        },
+
+        .power_ctrl       = ttusb2_power_ctrl,
+        .identify_state   = ttusb2_identify_state,
+
+        .i2c_algo         = &ttusb2_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "Technotrend TT-connect S-2400",
+                        { &ttusb2_table[2], NULL },
+                        { NULL },
+                },
+        }
+};
+
+static struct dvb_usb_device_properties ttusb2_properties_ct3650 = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+
+        .size_of_priv = sizeof(struct ttusb2_state),
+
+        .rc.core = {
+                .rc_interval      = 150, /* Less than IR_KEYPRESS_TIMEOUT */
+                .rc_codes         = RC_MAP_TT_1500,
+                .rc_query         = tt3650_rc_query,
+                .allowed_protos   = RC_TYPE_UNKNOWN,
+        },
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = NULL,
+
+                        .frontend_attach  = ttusb2_frontend_tda10023_attach,
+                        .tuner_attach = ttusb2_tuner_tda827x_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_ISOC,
+                                .count = 5,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .isoc = {
+                                                .framesperurb = 4,
+                                                .framesize = 940,
+                                                .interval = 1,
+                                        }
+                                }
+                        }
+                },
+        },
+
+        .power_ctrl       = ttusb2_power_ctrl,
+        .identify_state   = ttusb2_identify_state,
+
+        .i2c_algo         = &ttusb2_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "Technotrend TT-connect CT-3650",
+                        .warm_ids = { &ttusb2_table[3], NULL },
+                },
+        }
+};
+
+static struct usb_driver ttusb2_driver = {
+        .name           = "dvb_usb_ttusb2",
+        .probe          = ttusb2_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = ttusb2_table,
+};
+
+/* module stuff */
+static int __init ttusb2_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&ttusb2_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit ttusb2_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&ttusb2_driver);
+}
+
+module_init (ttusb2_module_init);
+module_exit (ttusb2_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for Pinnacle PCTV 400e DVB-S USB2.0");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/ttusb2.h b/drivers/media/dvb/dvb-usb/ttusb2.h
new file mode 100644
index 00000000000..52a63af4089
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/ttusb2.h
@@ -0,0 +1,70 @@
+/* DVB USB compliant linux driver for Technotrend DVB USB boxes and clones
+ * (e.g. Pinnacle 400e DVB-S USB2.0).
+ *
+ * Copyright (c) 2002 Holger Waechtler <holger@convergence.de>
+ * Copyright (c) 2003 Felix Domke <tmbinc@elitedvb.net>
+ * Copyright (C) 2005-6 Patrick Boettcher <pb@linuxtv.de>
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_TTUSB2_H_
+#define _DVB_USB_TTUSB2_H_
+
+/* TTUSB protocol
+ *
+ * always to messages (out/in)
+ * out message:
+ * 0xaa <id> <cmdbyte> <datalen> <data...>
+ *
+ * in message (complete block is always 0x40 bytes long)
+ * 0x55 <id> <cmdbyte> <datalen> <data...>
+ *
+ * id is incremented for each transaction
+ */
+
+#define CMD_DSP_DOWNLOAD    0x13
+/* out data: <byte>[28]
+ * last block must be empty */
+
+#define CMD_DSP_BOOT        0x14
+/* out data: nothing */
+
+#define CMD_POWER           0x15
+/* out data: <on=1/off=0> */
+
+#define CMD_LNB             0x16
+/* out data: <power=1> <18V=0,13V=1> <tone> <??=1> <??=1> */
+
+#define CMD_GET_VERSION     0x17
+/* in  data: <version_byte>[5] */
+
+#define CMD_DISEQC          0x18
+/* out data: <master=0xff/burst=??> <cmdlen> <cmdbytes>[cmdlen] */
+
+#define CMD_PID_ENABLE      0x22
+/* out data: <index> <type: ts=1/sec=2> <pid msb> <pid lsb> */
+
+#define CMD_PID_DISABLE     0x23
+/* out data: <index> */
+
+#define CMD_FILTER_ENABLE   0x24
+/* out data: <index> <pid_idx> <filter>[12] <mask>[12] */
+
+#define CMD_FILTER_DISABLE  0x25
+/* out data: <index> */
+
+#define CMD_GET_DSP_VERSION 0x26
+/* in  data: <version_byte>[28] */
+
+#define CMD_I2C_XFER        0x31
+/* out data: <addr << 1> <sndlen> <rcvlen> <data>[sndlen]
+ * in  data: <addr << 1> <sndlen> <rcvlen> <data>[rcvlen] */
+
+#define CMD_I2C_BITRATE     0x32
+/* out data: <default=0> */
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/umt-010.c b/drivers/media/dvb/dvb-usb/umt-010.c
new file mode 100644
index 00000000000..118aab1a3e5
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/umt-010.c
@@ -0,0 +1,168 @@
+/* DVB USB framework compliant Linux driver for the HanfTek UMT-010 USB2.0
+ * DVB-T receiver.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "dibusb.h"
+
+#include "mt352.h"
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static int umt_mt352_demod_init(struct dvb_frontend *fe)
+{
+        static u8 mt352_clock_config[] = { 0x89, 0xb8, 0x2d };
+        static u8 mt352_reset[] = { 0x50, 0x80 };
+        static u8 mt352_mclk_ratio[] = { 0x8b, 0x00 };
+        static u8 mt352_adc_ctl_1_cfg[] = { 0x8E, 0x40 };
+        static u8 mt352_agc_cfg[] = { 0x67, 0x10, 0xa0 };
+
+        static u8 mt352_sec_agc_cfg1[] = { 0x6a, 0xff };
+        static u8 mt352_sec_agc_cfg2[] = { 0x6d, 0xff };
+        static u8 mt352_sec_agc_cfg3[] = { 0x70, 0x40 };
+        static u8 mt352_sec_agc_cfg4[] = { 0x7b, 0x03 };
+        static u8 mt352_sec_agc_cfg5[] = { 0x7d, 0x0f };
+
+        static u8 mt352_acq_ctl[] = { 0x53, 0x50 };
+        static u8 mt352_input_freq_1[] = { 0x56, 0x31, 0x06 };
+
+        mt352_write(fe, mt352_clock_config, sizeof(mt352_clock_config));
+        udelay(2000);
+        mt352_write(fe, mt352_reset, sizeof(mt352_reset));
+        mt352_write(fe, mt352_mclk_ratio, sizeof(mt352_mclk_ratio));
+
+        mt352_write(fe, mt352_adc_ctl_1_cfg, sizeof(mt352_adc_ctl_1_cfg));
+        mt352_write(fe, mt352_agc_cfg, sizeof(mt352_agc_cfg));
+
+        mt352_write(fe, mt352_sec_agc_cfg1, sizeof(mt352_sec_agc_cfg1));
+        mt352_write(fe, mt352_sec_agc_cfg2, sizeof(mt352_sec_agc_cfg2));
+        mt352_write(fe, mt352_sec_agc_cfg3, sizeof(mt352_sec_agc_cfg3));
+        mt352_write(fe, mt352_sec_agc_cfg4, sizeof(mt352_sec_agc_cfg4));
+        mt352_write(fe, mt352_sec_agc_cfg5, sizeof(mt352_sec_agc_cfg5));
+
+        mt352_write(fe, mt352_acq_ctl, sizeof(mt352_acq_ctl));
+        mt352_write(fe, mt352_input_freq_1, sizeof(mt352_input_freq_1));
+
+        return 0;
+}
+
+static int umt_mt352_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        struct mt352_config umt_config;
+
+        memset(&umt_config,0,sizeof(struct mt352_config));
+        umt_config.demod_init = umt_mt352_demod_init;
+        umt_config.demod_address = 0xf;
+
+        adap->fe = dvb_attach(mt352_attach, &umt_config, &adap->dev->i2c_adap);
+
+        return 0;
+}
+
+static int umt_tuner_attach (struct dvb_usb_adapter *adap)
+{
+        dvb_attach(dvb_pll_attach, adap->fe, 0x61, NULL, DVB_PLL_TUA6034);
+        return 0;
+}
+
+/* USB Driver stuff */
+static struct dvb_usb_device_properties umt_properties;
+
+static int umt_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        if (0 == dvb_usb_device_init(intf, &umt_properties,
+                                     THIS_MODULE, NULL, adapter_nr))
+                return 0;
+        return -EINVAL;
+}
+
+/* do not change the order of the ID table */
+static struct usb_device_id umt_table [] = {
+/* 00 */        { USB_DEVICE(USB_VID_HANFTEK, USB_PID_HANFTEK_UMT_010_COLD) },
+/* 01 */        { USB_DEVICE(USB_VID_HANFTEK, USB_PID_HANFTEK_UMT_010_WARM) },
+                        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, umt_table);
+
+static struct dvb_usb_device_properties umt_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-umt-010-02.fw",
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .streaming_ctrl   = dibusb2_0_streaming_ctrl,
+                        .frontend_attach  = umt_mt352_frontend_attach,
+                        .tuner_attach     = umt_tuner_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = MAX_NO_URBS_FOR_DATA_STREAM,
+                                .endpoint = 0x06,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 512,
+                                        }
+                                }
+                        },
+
+                        .size_of_priv     = sizeof(struct dibusb_state),
+                }
+        },
+        .power_ctrl       = dibusb_power_ctrl,
+
+        .i2c_algo         = &dibusb_i2c_algo,
+
+        .generic_bulk_ctrl_endpoint = 0x01,
+
+        .num_device_descs = 1,
+        .devices = {
+                {       "Hanftek UMT-010 DVB-T USB2.0",
+                        { &umt_table[0], NULL },
+                        { &umt_table[1], NULL },
+                },
+        }
+};
+
+static struct usb_driver umt_driver = {
+        .name           = "dvb_usb_umt_010",
+        .probe          = umt_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = umt_table,
+};
+
+/* module stuff */
+static int __init umt_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&umt_driver))) {
+                err("usb_register failed. Error number %d",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit umt_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&umt_driver);
+}
+
+module_init (umt_module_init);
+module_exit (umt_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for HanfTek UMT 010 USB2.0 DVB-T device");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/usb-urb.c b/drivers/media/dvb/dvb-usb/usb-urb.c
new file mode 100644
index 00000000000..86d68933b6b
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/usb-urb.c
@@ -0,0 +1,254 @@
+/* usb-urb.c is part of the DVB USB library.
+ *
+ * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
+ * see dvb-usb-init.c for copyright information.
+ *
+ * This file keeps functions for initializing and handling the
+ * BULK and ISOC USB data transfers in a generic way.
+ * Can be used for DVB-only and also, that's the plan, for
+ * Hybrid USB devices (analog and DVB).
+ */
+#include "dvb-usb-common.h"
+
+/* URB stuff for streaming */
+static void usb_urb_complete(struct urb *urb)
+{
+        struct usb_data_stream *stream = urb->context;
+        int ptype = usb_pipetype(urb->pipe);
+        int i;
+        u8 *b;
+
+        deb_uxfer("'%s' urb completed. status: %d, length: %d/%d, pack_num: %d, errors: %d\n",
+                ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk",
+                urb->status,urb->actual_length,urb->transfer_buffer_length,
+                urb->number_of_packets,urb->error_count);
+
+        switch (urb->status) {
+                case 0:         /* success */
+                case -ETIMEDOUT:    /* NAK */
+                        break;
+                case -ECONNRESET:   /* kill */
+                case -ENOENT:
+                case -ESHUTDOWN:
+                        return;
+                default:        /* error */
+                        deb_ts("urb completition error %d.\n", urb->status);
+                        break;
+        }
+
+        b = (u8 *) urb->transfer_buffer;
+        switch (ptype) {
+                case PIPE_ISOCHRONOUS:
+                        for (i = 0; i < urb->number_of_packets; i++) {
+
+                                if (urb->iso_frame_desc[i].status != 0)
+                                        deb_ts("iso frame descriptor has an error: %d\n",urb->iso_frame_desc[i].status);
+                                else if (urb->iso_frame_desc[i].actual_length > 0)
+                                        stream->complete(stream, b + urb->iso_frame_desc[i].offset, urb->iso_frame_desc[i].actual_length);
+
+                                urb->iso_frame_desc[i].status = 0;
+                                urb->iso_frame_desc[i].actual_length = 0;
+                        }
+                        debug_dump(b,20,deb_uxfer);
+                        break;
+                case PIPE_BULK:
+                        if (urb->actual_length > 0)
+                                stream->complete(stream, b, urb->actual_length);
+                        break;
+                default:
+                        err("unknown endpoint type in completition handler.");
+                        return;
+        }
+        usb_submit_urb(urb,GFP_ATOMIC);
+}
+
+int usb_urb_kill(struct usb_data_stream *stream)
+{
+        int i;
+        for (i = 0; i < stream->urbs_submitted; i++) {
+                deb_ts("killing URB no. %d.\n",i);
+
+                /* stop the URB */
+                usb_kill_urb(stream->urb_list[i]);
+        }
+        stream->urbs_submitted = 0;
+        return 0;
+}
+
+int usb_urb_submit(struct usb_data_stream *stream)
+{
+        int i,ret;
+        for (i = 0; i < stream->urbs_initialized; i++) {
+                deb_ts("submitting URB no. %d\n",i);
+                if ((ret = usb_submit_urb(stream->urb_list[i],GFP_ATOMIC))) {
+                        err("could not submit URB no. %d - get them all back",i);
+                        usb_urb_kill(stream);
+                        return ret;
+                }
+                stream->urbs_submitted++;
+        }
+        return 0;
+}
+
+static int usb_free_stream_buffers(struct usb_data_stream *stream)
+{
+        if (stream->state & USB_STATE_URB_BUF) {
+                while (stream->buf_num) {
+                        stream->buf_num--;
+                        deb_mem("freeing buffer %d\n",stream->buf_num);
+                        usb_free_coherent(stream->udev, stream->buf_size,
+                                          stream->buf_list[stream->buf_num],
+                                          stream->dma_addr[stream->buf_num]);
+                }
+        }
+
+        stream->state &= ~USB_STATE_URB_BUF;
+
+        return 0;
+}
+
+static int usb_allocate_stream_buffers(struct usb_data_stream *stream, int num, unsigned long size)
+{
+        stream->buf_num = 0;
+        stream->buf_size = size;
+
+        deb_mem("all in all I will use %lu bytes for streaming\n",num*size);
+
+        for (stream->buf_num = 0; stream->buf_num < num; stream->buf_num++) {
+                deb_mem("allocating buffer %d\n",stream->buf_num);
+                if (( stream->buf_list[stream->buf_num] =
+                                        usb_alloc_coherent(stream->udev, size, GFP_ATOMIC,
+                                        &stream->dma_addr[stream->buf_num]) ) == NULL) {
+                        deb_mem("not enough memory for urb-buffer allocation.\n");
+                        usb_free_stream_buffers(stream);
+                        return -ENOMEM;
+                }
+                deb_mem("buffer %d: %p (dma: %Lu)\n",
+                        stream->buf_num,
+stream->buf_list[stream->buf_num], (long long)stream->dma_addr[stream->buf_num]);
+                memset(stream->buf_list[stream->buf_num],0,size);
+                stream->state |= USB_STATE_URB_BUF;
+        }
+        deb_mem("allocation successful\n");
+
+        return 0;
+}
+
+static int usb_bulk_urb_init(struct usb_data_stream *stream)
+{
+        int i, j;
+
+        if ((i = usb_allocate_stream_buffers(stream,stream->props.count,
+                                        stream->props.u.bulk.buffersize)) < 0)
+                return i;
+
+        /* allocate the URBs */
+        for (i = 0; i < stream->props.count; i++) {
+                stream->urb_list[i] = usb_alloc_urb(0, GFP_ATOMIC);
+                if (!stream->urb_list[i]) {
+                        deb_mem("not enough memory for urb_alloc_urb!.\n");
+                        for (j = 0; j < i; j++)
+                                usb_free_urb(stream->urb_list[i]);
+                        return -ENOMEM;
+                }
+                usb_fill_bulk_urb( stream->urb_list[i], stream->udev,
+                                usb_rcvbulkpipe(stream->udev,stream->props.endpoint),
+                                stream->buf_list[i],
+                                stream->props.u.bulk.buffersize,
+                                usb_urb_complete, stream);
+
+                stream->urb_list[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+                stream->urb_list[i]->transfer_dma = stream->dma_addr[i];
+                stream->urbs_initialized++;
+        }
+        return 0;
+}
+
+static int usb_isoc_urb_init(struct usb_data_stream *stream)
+{
+        int i,j;
+
+        if ((i = usb_allocate_stream_buffers(stream,stream->props.count,
+                                        stream->props.u.isoc.framesize*stream->props.u.isoc.framesperurb)) < 0)
+                return i;
+
+        /* allocate the URBs */
+        for (i = 0; i < stream->props.count; i++) {
+                struct urb *urb;
+                int frame_offset = 0;
+
+                stream->urb_list[i] = usb_alloc_urb(stream->props.u.isoc.framesperurb, GFP_ATOMIC);
+                if (!stream->urb_list[i]) {
+                        deb_mem("not enough memory for urb_alloc_urb!\n");
+                        for (j = 0; j < i; j++)
+                                usb_free_urb(stream->urb_list[i]);
+                        return -ENOMEM;
+                }
+
+                urb = stream->urb_list[i];
+
+                urb->dev = stream->udev;
+                urb->context = stream;
+                urb->complete = usb_urb_complete;
+                urb->pipe = usb_rcvisocpipe(stream->udev,stream->props.endpoint);
+                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+                urb->interval = stream->props.u.isoc.interval;
+                urb->number_of_packets = stream->props.u.isoc.framesperurb;
+                urb->transfer_buffer_length = stream->buf_size;
+                urb->transfer_buffer = stream->buf_list[i];
+                urb->transfer_dma = stream->dma_addr[i];
+
+                for (j = 0; j < stream->props.u.isoc.framesperurb; j++) {
+                        urb->iso_frame_desc[j].offset = frame_offset;
+                        urb->iso_frame_desc[j].length = stream->props.u.isoc.framesize;
+                        frame_offset += stream->props.u.isoc.framesize;
+                }
+
+                stream->urbs_initialized++;
+        }
+        return 0;
+}
+
+int usb_urb_init(struct usb_data_stream *stream, struct usb_data_stream_properties *props)
+{
+        if (stream == NULL || props == NULL)
+                return -EINVAL;
+
+        memcpy(&stream->props, props, sizeof(*props));
+
+        usb_clear_halt(stream->udev,usb_rcvbulkpipe(stream->udev,stream->props.endpoint));
+
+        if (stream->complete == NULL) {
+                err("there is no data callback - this doesn't make sense.");
+                return -EINVAL;
+        }
+
+        switch (stream->props.type) {
+                case USB_BULK:
+                        return usb_bulk_urb_init(stream);
+                case USB_ISOC:
+                        return usb_isoc_urb_init(stream);
+                default:
+                        err("unknown URB-type for data transfer.");
+                        return -EINVAL;
+        }
+}
+
+int usb_urb_exit(struct usb_data_stream *stream)
+{
+        int i;
+
+        usb_urb_kill(stream);
+
+        for (i = 0; i < stream->urbs_initialized; i++) {
+                if (stream->urb_list[i] != NULL) {
+                        deb_mem("freeing URB no. %d.\n",i);
+                        /* free the URBs */
+                        usb_free_urb(stream->urb_list[i]);
+                }
+        }
+        stream->urbs_initialized = 0;
+
+        usb_free_stream_buffers(stream);
+        return 0;
+}
diff --git a/drivers/media/dvb/dvb-usb/vp702x-fe.c b/drivers/media/dvb/dvb-usb/vp702x-fe.c
new file mode 100644
index 00000000000..2bb8d4cc8d8
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp702x-fe.c
@@ -0,0 +1,387 @@
+/* DVB frontend part of the Linux driver for the TwinhanDTV StarBox USB2.0
+ * DVB-S receiver.
+ *
+ * Copyright (C) 2005 Ralph Metzler <rjkm@metzlerbros.de>
+ *                    Metzler Brothers Systementwicklung GbR
+ *
+ * Copyright (C) 2005 Patrick Boettcher <patrick.boettcher@desy.de>
+ *
+ * Thanks to Twinhan who kindly provided hardware and information.
+ *
+ * This file can be removed soon, after the DST-driver is rewritten to provice
+ * the frontend-controlling separately.
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ *
+ */
+#include "vp702x.h"
+
+struct vp702x_fe_state {
+        struct dvb_frontend fe;
+        struct dvb_usb_device *d;
+
+        struct dvb_frontend_ops ops;
+
+        fe_sec_voltage_t voltage;
+        fe_sec_tone_mode_t tone_mode;
+
+        u8 lnb_buf[8];
+
+        u8 lock;
+        u8 sig;
+        u8 snr;
+
+        unsigned long next_status_check;
+        unsigned long status_check_interval;
+};
+
+static int vp702x_fe_refresh_state(struct vp702x_fe_state *st)
+{
+        struct vp702x_device_state *dst = st->d->priv;
+        u8 *buf;
+
+        if (time_after(jiffies, st->next_status_check)) {
+                mutex_lock(&dst->buf_mutex);
+                buf = dst->buf;
+
+                vp702x_usb_in_op(st->d, READ_STATUS, 0, 0, buf, 10);
+                st->lock = buf[4];
+
+                vp702x_usb_in_op(st->d, READ_TUNER_REG_REQ, 0x11, 0, buf, 1);
+                st->snr = buf[0];
+
+                vp702x_usb_in_op(st->d, READ_TUNER_REG_REQ, 0x15, 0, buf, 1);
+                st->sig = buf[0];
+
+                mutex_unlock(&dst->buf_mutex);
+                st->next_status_check = jiffies + (st->status_check_interval*HZ)/1000;
+        }
+        return 0;
+}
+
+static u8 vp702x_chksum(u8 *buf,int f, int count)
+{
+        u8 s = 0;
+        int i;
+        for (i = f; i < f+count; i++)
+                s += buf[i];
+        return ~s+1;
+}
+
+static int vp702x_fe_read_status(struct dvb_frontend* fe, fe_status_t *status)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+        deb_fe("%s\n",__func__);
+
+        if (st->lock == 0)
+                *status = FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_SIGNAL | FE_HAS_CARRIER;
+        else
+                *status = 0;
+
+        if (*status & FE_HAS_LOCK)
+                st->status_check_interval = 1000;
+        else
+                st->status_check_interval = 250;
+        return 0;
+}
+
+/* not supported by this Frontend */
+static int vp702x_fe_read_ber(struct dvb_frontend* fe, u32 *ber)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+        *ber = 0;
+        return 0;
+}
+
+/* not supported by this Frontend */
+static int vp702x_fe_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+        *unc = 0;
+        return 0;
+}
+
+static int vp702x_fe_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+
+        *strength = (st->sig << 8) | st->sig;
+        return 0;
+}
+
+static int vp702x_fe_read_snr(struct dvb_frontend* fe, u16 *snr)
+{
+        u8 _snr;
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+
+        _snr = (st->snr & 0x1f) * 0xff / 0x1f;
+        *snr = (_snr << 8) | _snr;
+        return 0;
+}
+
+static int vp702x_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
+{
+        deb_fe("%s\n",__func__);
+        tune->min_delay_ms = 2000;
+        return 0;
+}
+
+static int vp702x_fe_set_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        struct vp702x_device_state *dst = st->d->priv;
+        u32 freq = fep->frequency/1000;
+        /*CalFrequency*/
+/*      u16 frequencyRef[16] = { 2, 4, 8, 16, 32, 64, 128, 256, 24, 5, 10, 20, 40, 80, 160, 320 }; */
+        u64 sr;
+        u8 *cmd;
+
+        mutex_lock(&dst->buf_mutex);
+
+        cmd = dst->buf;
+        memset(cmd, 0, 10);
+
+        cmd[0] = (freq >> 8) & 0x7f;
+        cmd[1] =  freq       & 0xff;
+        cmd[2] = 1; /* divrate == 4 -> frequencyRef[1] -> 1 here */
+
+        sr = (u64) (fep->u.qpsk.symbol_rate/1000) << 20;
+        do_div(sr,88000);
+        cmd[3] = (sr >> 12) & 0xff;
+        cmd[4] = (sr >> 4)  & 0xff;
+        cmd[5] = (sr << 4)  & 0xf0;
+
+        deb_fe("setting frontend to: %u -> %u (%x) LNB-based GHz, symbolrate: %d -> %lu (%lx)\n",
+                        fep->frequency,freq,freq, fep->u.qpsk.symbol_rate,
+                        (unsigned long) sr, (unsigned long) sr);
+
+/*      if (fep->inversion == INVERSION_ON)
+                cmd[6] |= 0x80; */
+
+        if (st->voltage == SEC_VOLTAGE_18)
+                cmd[6] |= 0x40;
+
+/*      if (fep->u.qpsk.symbol_rate > 8000000)
+                cmd[6] |= 0x20;
+
+        if (fep->frequency < 1531000)
+                cmd[6] |= 0x04;
+
+        if (st->tone_mode == SEC_TONE_ON)
+                cmd[6] |= 0x01;*/
+
+        cmd[7] = vp702x_chksum(cmd,0,7);
+
+        st->status_check_interval = 250;
+        st->next_status_check = jiffies;
+
+        vp702x_usb_inout_op(st->d, cmd, 8, cmd, 10, 100);
+
+        if (cmd[2] == 0 && cmd[3] == 0)
+                deb_fe("tuning failed.\n");
+        else
+                deb_fe("tuning succeeded.\n");
+
+        mutex_unlock(&dst->buf_mutex);
+
+        return 0;
+}
+
+static int vp702x_fe_init(struct dvb_frontend *fe)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        deb_fe("%s\n",__func__);
+        vp702x_usb_in_op(st->d, RESET_TUNER, 0, 0, NULL, 0);
+        return 0;
+}
+
+static int vp702x_fe_sleep(struct dvb_frontend *fe)
+{
+        deb_fe("%s\n",__func__);
+        return 0;
+}
+
+static int vp702x_fe_get_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        deb_fe("%s\n",__func__);
+        return 0;
+}
+
+static int vp702x_fe_send_diseqc_msg (struct dvb_frontend* fe,
+                                    struct dvb_diseqc_master_cmd *m)
+{
+        u8 *cmd;
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        struct vp702x_device_state *dst = st->d->priv;
+
+        deb_fe("%s\n",__func__);
+
+        if (m->msg_len > 4)
+                return -EINVAL;
+
+        mutex_lock(&dst->buf_mutex);
+
+        cmd = dst->buf;
+        cmd[1] = SET_DISEQC_CMD;
+        cmd[2] = m->msg_len;
+        memcpy(&cmd[3], m->msg, m->msg_len);
+        cmd[7] = vp702x_chksum(cmd, 0, 7);
+
+        vp702x_usb_inout_op(st->d, cmd, 8, cmd, 10, 100);
+
+        if (cmd[2] == 0 && cmd[3] == 0)
+                deb_fe("diseqc cmd failed.\n");
+        else
+                deb_fe("diseqc cmd succeeded.\n");
+
+        mutex_unlock(&dst->buf_mutex);
+
+        return 0;
+}
+
+static int vp702x_fe_send_diseqc_burst (struct dvb_frontend* fe, fe_sec_mini_cmd_t burst)
+{
+        deb_fe("%s\n",__func__);
+        return 0;
+}
+
+static int vp702x_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        struct vp702x_device_state *dst = st->d->priv;
+        u8 *buf;
+
+        deb_fe("%s\n",__func__);
+
+        st->tone_mode = tone;
+
+        if (tone == SEC_TONE_ON)
+                st->lnb_buf[2] = 0x02;
+        else
+                st->lnb_buf[2] = 0x00;
+
+        st->lnb_buf[7] = vp702x_chksum(st->lnb_buf, 0, 7);
+
+        mutex_lock(&dst->buf_mutex);
+
+        buf = dst->buf;
+        memcpy(buf, st->lnb_buf, 8);
+
+        vp702x_usb_inout_op(st->d, buf, 8, buf, 10, 100);
+        if (buf[2] == 0 && buf[3] == 0)
+                deb_fe("set_tone cmd failed.\n");
+        else
+                deb_fe("set_tone cmd succeeded.\n");
+
+        mutex_unlock(&dst->buf_mutex);
+
+        return 0;
+}
+
+static int vp702x_fe_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t
+                voltage)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        struct vp702x_device_state *dst = st->d->priv;
+        u8 *buf;
+        deb_fe("%s\n",__func__);
+
+        st->voltage = voltage;
+
+        if (voltage != SEC_VOLTAGE_OFF)
+                st->lnb_buf[4] = 0x01;
+        else
+                st->lnb_buf[4] = 0x00;
+
+        st->lnb_buf[7] = vp702x_chksum(st->lnb_buf, 0, 7);
+
+        mutex_lock(&dst->buf_mutex);
+
+        buf = dst->buf;
+        memcpy(buf, st->lnb_buf, 8);
+
+        vp702x_usb_inout_op(st->d, buf, 8, buf, 10, 100);
+        if (buf[2] == 0 && buf[3] == 0)
+                deb_fe("set_voltage cmd failed.\n");
+        else
+                deb_fe("set_voltage cmd succeeded.\n");
+
+        mutex_unlock(&dst->buf_mutex);
+        return 0;
+}
+
+static void vp702x_fe_release(struct dvb_frontend* fe)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        kfree(st);
+}
+
+static struct dvb_frontend_ops vp702x_fe_ops;
+
+struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d)
+{
+        struct vp702x_fe_state *s = kzalloc(sizeof(struct vp702x_fe_state), GFP_KERNEL);
+        if (s == NULL)
+                goto error;
+
+        s->d = d;
+
+        memcpy(&s->fe.ops,&vp702x_fe_ops,sizeof(struct dvb_frontend_ops));
+        s->fe.demodulator_priv = s;
+
+        s->lnb_buf[1] = SET_LNB_POWER;
+        s->lnb_buf[3] = 0xff; /* 0=tone burst, 2=data burst, ff=off */
+
+        return &s->fe;
+error:
+        return NULL;
+}
+
+
+static struct dvb_frontend_ops vp702x_fe_ops = {
+        .info = {
+                .name           = "Twinhan DST-like frontend (VP7021/VP7020) DVB-S",
+                .type           = FE_QPSK,
+                .frequency_min       = 950000,
+                .frequency_max       = 2150000,
+                .frequency_stepsize  = 1000,   /* kHz for QPSK frontends */
+                .frequency_tolerance = 0,
+                .symbol_rate_min     = 1000000,
+                .symbol_rate_max     = 45000000,
+                .symbol_rate_tolerance = 500,  /* ppm */
+                .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
+                FE_CAN_QPSK |
+                FE_CAN_FEC_AUTO
+        },
+        .release = vp702x_fe_release,
+
+        .init  = vp702x_fe_init,
+        .sleep = vp702x_fe_sleep,
+
+        .set_frontend = vp702x_fe_set_frontend,
+        .get_frontend = vp702x_fe_get_frontend,
+        .get_tune_settings = vp702x_fe_get_tune_settings,
+
+        .read_status = vp702x_fe_read_status,
+        .read_ber = vp702x_fe_read_ber,
+        .read_signal_strength = vp702x_fe_read_signal_strength,
+        .read_snr = vp702x_fe_read_snr,
+        .read_ucblocks = vp702x_fe_read_unc_blocks,
+
+        .diseqc_send_master_cmd = vp702x_fe_send_diseqc_msg,
+        .diseqc_send_burst = vp702x_fe_send_diseqc_burst,
+        .set_tone = vp702x_fe_set_tone,
+        .set_voltage = vp702x_fe_set_voltage,
+};
diff --git a/drivers/media/dvb/dvb-usb/vp702x.c b/drivers/media/dvb/dvb-usb/vp702x.c
new file mode 100644
index 00000000000..54355f84a98
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp702x.c
@@ -0,0 +1,460 @@
+/* DVB USB compliant Linux driver for the TwinhanDTV StarBox USB2.0 DVB-S
+ * receiver.
+ *
+ * Copyright (C) 2005 Ralph Metzler <rjkm@metzlerbros.de>
+ *                    Metzler Brothers Systementwicklung GbR
+ *
+ * Copyright (C) 2005 Patrick Boettcher <patrick.boettcher@desy.de>
+ *
+ * Thanks to Twinhan who kindly provided hardware and information.
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "vp702x.h"
+#include <linux/mutex.h>
+
+/* debug */
+int dvb_usb_vp702x_debug;
+module_param_named(debug,dvb_usb_vp702x_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+struct vp702x_adapter_state {
+        int pid_filter_count;
+        int pid_filter_can_bypass;
+        u8  pid_filter_state;
+};
+
+static int vp702x_usb_in_op_unlocked(struct dvb_usb_device *d, u8 req,
+                                     u16 value, u16 index, u8 *b, int blen)
+{
+        int ret;
+
+        ret = usb_control_msg(d->udev,
+                usb_rcvctrlpipe(d->udev, 0),
+                req,
+                USB_TYPE_VENDOR | USB_DIR_IN,
+                value, index, b, blen,
+                2000);
+
+        if (ret < 0) {
+                warn("usb in operation failed. (%d)", ret);
+                ret = -EIO;
+        } else
+                ret = 0;
+
+
+        deb_xfer("in: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index);
+        debug_dump(b,blen,deb_xfer);
+
+        return ret;
+}
+
+int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value,
+                            u16 index, u8 *b, int blen)
+{
+        int ret;
+
+        mutex_lock(&d->usb_mutex);
+        ret = vp702x_usb_in_op_unlocked(d, req, value, index, b, blen);
+        mutex_unlock(&d->usb_mutex);
+
+        return ret;
+}
+
+int vp702x_usb_out_op_unlocked(struct dvb_usb_device *d, u8 req, u16 value,
+                                      u16 index, u8 *b, int blen)
+{
+        int ret;
+        deb_xfer("out: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index);
+        debug_dump(b,blen,deb_xfer);
+
+        if ((ret = usb_control_msg(d->udev,
+                        usb_sndctrlpipe(d->udev,0),
+                        req,
+                        USB_TYPE_VENDOR | USB_DIR_OUT,
+                        value,index,b,blen,
+                        2000)) != blen) {
+                warn("usb out operation failed. (%d)",ret);
+                return -EIO;
+        } else
+                return 0;
+}
+
+int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
+                             u16 index, u8 *b, int blen)
+{
+        int ret;
+
+        mutex_lock(&d->usb_mutex);
+        ret = vp702x_usb_out_op_unlocked(d, req, value, index, b, blen);
+        mutex_unlock(&d->usb_mutex);
+
+        return ret;
+}
+
+int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec)
+{
+        int ret;
+
+        if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
+                return ret;
+
+        ret = vp702x_usb_out_op_unlocked(d, REQUEST_OUT, 0, 0, o, olen);
+        msleep(msec);
+        ret = vp702x_usb_in_op_unlocked(d, REQUEST_IN, 0, 0, i, ilen);
+
+        mutex_unlock(&d->usb_mutex);
+        return ret;
+}
+
+static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o,
+                                int olen, u8 *i, int ilen, int msec)
+{
+        struct vp702x_device_state *st = d->priv;
+        int ret = 0;
+        u8 *buf;
+        int buflen = max(olen + 2, ilen + 1);
+
+        ret = mutex_lock_interruptible(&st->buf_mutex);
+        if (ret < 0)
+                return ret;
+
+        if (buflen > st->buf_len) {
+                buf = kmalloc(buflen, GFP_KERNEL);
+                if (!buf) {
+                        mutex_unlock(&st->buf_mutex);
+                        return -ENOMEM;
+                }
+                info("successfully reallocated a bigger buffer");
+                kfree(st->buf);
+                st->buf = buf;
+                st->buf_len = buflen;
+        } else {
+                buf = st->buf;
+        }
+
+        buf[0] = 0x00;
+        buf[1] = cmd;
+        memcpy(&buf[2], o, olen);
+
+        ret = vp702x_usb_inout_op(d, buf, olen+2, buf, ilen+1, msec);
+
+        if (ret == 0)
+                memcpy(i, &buf[1], ilen);
+        mutex_unlock(&st->buf_mutex);
+
+        return ret;
+}
+
+static int vp702x_set_pld_mode(struct dvb_usb_adapter *adap, u8 bypass)
+{
+        int ret;
+        struct vp702x_device_state *st = adap->dev->priv;
+        u8 *buf;
+
+        mutex_lock(&st->buf_mutex);
+
+        buf = st->buf;
+        memset(buf, 0, 16);
+
+        ret = vp702x_usb_in_op(adap->dev, 0xe0, (bypass << 8) | 0x0e,
+                        0, buf, 16);
+        mutex_unlock(&st->buf_mutex);
+        return ret;
+}
+
+static int vp702x_set_pld_state(struct dvb_usb_adapter *adap, u8 state)
+{
+        int ret;
+        struct vp702x_device_state *st = adap->dev->priv;
+        u8 *buf;
+
+        mutex_lock(&st->buf_mutex);
+
+        buf = st->buf;
+        memset(buf, 0, 16);
+        ret = vp702x_usb_in_op(adap->dev, 0xe0, (state << 8) | 0x0f,
+                        0, buf, 16);
+
+        mutex_unlock(&st->buf_mutex);
+
+        return ret;
+}
+
+static int vp702x_set_pid(struct dvb_usb_adapter *adap, u16 pid, u8 id, int onoff)
+{
+        struct vp702x_adapter_state *st = adap->priv;
+        struct vp702x_device_state *dst = adap->dev->priv;
+        u8 *buf;
+
+        if (onoff)
+                st->pid_filter_state |=  (1 << id);
+        else {
+                st->pid_filter_state &= ~(1 << id);
+                pid = 0xffff;
+        }
+
+        id = 0x10 + id*2;
+
+        vp702x_set_pld_state(adap, st->pid_filter_state);
+
+        mutex_lock(&dst->buf_mutex);
+
+        buf = dst->buf;
+        memset(buf, 0, 16);
+        vp702x_usb_in_op(adap->dev, 0xe0, (((pid >> 8) & 0xff) << 8) | (id), 0, buf, 16);
+        vp702x_usb_in_op(adap->dev, 0xe0, (((pid     ) & 0xff) << 8) | (id+1), 0, buf, 16);
+
+        mutex_unlock(&dst->buf_mutex);
+
+        return 0;
+}
+
+
+static int vp702x_init_pid_filter(struct dvb_usb_adapter *adap)
+{
+        struct vp702x_adapter_state *st = adap->priv;
+        struct vp702x_device_state *dst = adap->dev->priv;
+        int i;
+        u8 *b;
+
+        st->pid_filter_count = 8;
+        st->pid_filter_can_bypass = 1;
+        st->pid_filter_state = 0x00;
+
+        vp702x_set_pld_mode(adap, 1); /* bypass */
+
+        for (i = 0; i < st->pid_filter_count; i++)
+                vp702x_set_pid(adap, 0xffff, i, 1);
+
+        mutex_lock(&dst->buf_mutex);
+        b = dst->buf;
+        memset(b, 0, 10);
+        vp702x_usb_in_op(adap->dev, 0xb5, 3, 0, b, 10);
+        vp702x_usb_in_op(adap->dev, 0xb5, 0, 0, b, 10);
+        vp702x_usb_in_op(adap->dev, 0xb5, 1, 0, b, 10);
+        mutex_unlock(&dst->buf_mutex);
+        /*vp702x_set_pld_mode(d, 0); // filter */
+
+        return 0;
+}
+
+static int vp702x_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        return 0;
+}
+
+/* keys for the enclosed remote control */
+static struct rc_map_table rc_map_vp702x_table[] = {
+        { 0x0001, KEY_1 },
+        { 0x0002, KEY_2 },
+};
+
+/* remote control stuff (does not work with my box) */
+static int vp702x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        u8 *key;
+        int i;
+
+/* remove the following return to enabled remote querying */
+        return 0;
+
+        key = kmalloc(10, GFP_KERNEL);
+        if (!key)
+                return -ENOMEM;
+
+        vp702x_usb_in_op(d,READ_REMOTE_REQ,0,0,key,10);
+
+        deb_rc("remote query key: %x %d\n",key[1],key[1]);
+
+        if (key[1] == 0x44) {
+                *state = REMOTE_NO_KEY_PRESSED;
+                kfree(key);
+                return 0;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(rc_map_vp702x_table); i++)
+                if (rc5_custom(&rc_map_vp702x_table[i]) == key[1]) {
+                        *state = REMOTE_KEY_PRESSED;
+                        *event = rc_map_vp702x_table[i].keycode;
+                        break;
+                }
+        kfree(key);
+        return 0;
+}
+
+
+static int vp702x_read_mac_addr(struct dvb_usb_device *d,u8 mac[6])
+{
+        u8 i, *buf;
+        struct vp702x_device_state *st = d->priv;
+
+        mutex_lock(&st->buf_mutex);
+        buf = st->buf;
+        for (i = 6; i < 12; i++)
+                vp702x_usb_in_op(d, READ_EEPROM_REQ, i, 1, &buf[i - 6], 1);
+
+        memcpy(mac, buf, 6);
+        mutex_unlock(&st->buf_mutex);
+        return 0;
+}
+
+static int vp702x_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        u8 buf[10] = { 0 };
+
+        vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 0, 7, NULL, 0);
+
+        if (vp702x_usb_inout_cmd(adap->dev, GET_SYSTEM_STRING, NULL, 0,
+                                   buf, 10, 10))
+                return -EIO;
+
+        buf[9] = '\0';
+        info("system string: %s",&buf[1]);
+
+        vp702x_init_pid_filter(adap);
+
+        adap->fe = vp702x_fe_attach(adap->dev);
+        vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 1, 7, NULL, 0);
+
+        return 0;
+}
+
+static struct dvb_usb_device_properties vp702x_properties;
+
+static int vp702x_usb_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        struct dvb_usb_device *d;
+        struct vp702x_device_state *st;
+        int ret;
+
+        ret = dvb_usb_device_init(intf, &vp702x_properties,
+                                   THIS_MODULE, &d, adapter_nr);
+        if (ret)
+                goto out;
+
+        st = d->priv;
+        st->buf_len = 16;
+        st->buf = kmalloc(st->buf_len, GFP_KERNEL);
+        if (!st->buf) {
+                ret = -ENOMEM;
+                dvb_usb_device_exit(intf);
+                goto out;
+        }
+        mutex_init(&st->buf_mutex);
+
+out:
+        return ret;
+
+}
+
+static void vp702x_usb_disconnect(struct usb_interface *intf)
+{
+        struct dvb_usb_device *d = usb_get_intfdata(intf);
+        struct vp702x_device_state *st = d->priv;
+        mutex_lock(&st->buf_mutex);
+        kfree(st->buf);
+        mutex_unlock(&st->buf_mutex);
+        dvb_usb_device_exit(intf);
+}
+
+static struct usb_device_id vp702x_usb_table [] = {
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_COLD) },
+//          { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_COLD) },
+//          { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_WARM) },
+            { 0 },
+};
+MODULE_DEVICE_TABLE(usb, vp702x_usb_table);
+
+static struct dvb_usb_device_properties vp702x_properties = {
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware            = "dvb-usb-vp702x-02.fw",
+        .no_reconnect        = 1,
+
+        .size_of_priv     = sizeof(struct vp702x_device_state),
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .caps             = DVB_USB_ADAP_RECEIVES_204_BYTE_TS,
+
+                        .streaming_ctrl   = vp702x_streaming_ctrl,
+                        .frontend_attach  = vp702x_frontend_attach,
+
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 10,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                        .size_of_priv     = sizeof(struct vp702x_adapter_state),
+                }
+        },
+        .read_mac_address = vp702x_read_mac_addr,
+
+        .rc.legacy = {
+                .rc_map_table       = rc_map_vp702x_table,
+                .rc_map_size  = ARRAY_SIZE(rc_map_vp702x_table),
+                .rc_interval      = 400,
+                .rc_query         = vp702x_rc_query,
+        },
+
+        .num_device_descs = 1,
+        .devices = {
+                { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7021)",
+                  .cold_ids = { &vp702x_usb_table[0], NULL },
+                  .warm_ids = { NULL },
+                },
+/*              { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7020)",
+                  .cold_ids = { &vp702x_usb_table[2], NULL },
+                  .warm_ids = { &vp702x_usb_table[3], NULL },
+                },
+*/              { NULL },
+        }
+};
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver vp702x_usb_driver = {
+        .name           = "dvb_usb_vp702x",
+        .probe          = vp702x_usb_probe,
+        .disconnect     = vp702x_usb_disconnect,
+        .id_table       = vp702x_usb_table,
+};
+
+/* module stuff */
+static int __init vp702x_usb_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&vp702x_usb_driver))) {
+                err("usb_register failed. (%d)",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit vp702x_usb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&vp702x_usb_driver);
+}
+
+module_init(vp702x_usb_module_init);
+module_exit(vp702x_usb_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for Twinhan StarBox DVB-S USB2.0 and clones");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/vp702x.h b/drivers/media/dvb/dvb-usb/vp702x.h
new file mode 100644
index 00000000000..20b90055e7a
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp702x.h
@@ -0,0 +1,113 @@
+#ifndef _DVB_USB_VP7021_H_
+#define _DVB_USB_VP7021_H_
+
+#define DVB_USB_LOG_PREFIX "vp702x"
+#include "dvb-usb.h"
+
+extern int dvb_usb_vp702x_debug;
+#define deb_info(args...) dprintk(dvb_usb_vp702x_debug,0x01,args)
+#define deb_xfer(args...) dprintk(dvb_usb_vp702x_debug,0x02,args)
+#define deb_rc(args...)   dprintk(dvb_usb_vp702x_debug,0x04,args)
+#define deb_fe(args...)   dprintk(dvb_usb_vp702x_debug,0x08,args)
+
+/* commands are read and written with USB control messages */
+
+/* consecutive read/write operation */
+#define REQUEST_OUT             0xB2
+#define REQUEST_IN              0xB3
+
+/* the out-buffer of these consecutive operations contain sub-commands when b[0] = 0
+ * request: 0xB2; i: 0; v: 0; b[0] = 0, b[1] = subcmd, additional buffer
+ * the returning buffer looks as follows
+ * request: 0xB3; i: 0; v: 0; b[0] = 0xB3, additional buffer */
+
+#define GET_TUNER_STATUS        0x05
+/* additional in buffer:
+ * 0   1   2    3              4   5   6               7       8
+ * N/A N/A 0x05 signal-quality N/A N/A signal-strength lock==0 N/A */
+
+#define GET_SYSTEM_STRING       0x06
+/* additional in buffer:
+ * 0   1   2   3   4   5   6   7   8
+ * N/A 'U' 'S' 'B' '7' '0' '2' 'X' N/A */
+
+#define SET_DISEQC_CMD          0x08
+/* additional out buffer:
+ * 0    1  2  3  4
+ * len  X1 X2 X3 X4
+ * additional in buffer:
+ * 0   1 2
+ * N/A 0 0   b[1] == b[2] == 0 -> success, failure otherwise */
+
+#define SET_LNB_POWER           0x09
+/* additional out buffer:
+ * 0    1    2
+ * 0x00 0xff 1 = on, 0 = off
+ * additional in buffer:
+ * 0   1 2
+ * N/A 0 0   b[1] == b[2] == 0 -> success failure otherwise */
+
+#define GET_MAC_ADDRESS         0x0A
+/* #define GET_MAC_ADDRESS   0x0B */
+/* additional in buffer:
+ * 0   1   2            3    4    5    6    7    8
+ * N/A N/A 0x0A or 0x0B MAC0 MAC1 MAC2 MAC3 MAC4 MAC5 */
+
+#define SET_PID_FILTER          0x11
+/* additional in buffer:
+ * 0        1        ... 14       15       16
+ * PID0_MSB PID0_LSB ... PID7_MSB PID7_LSB PID_active (bits) */
+
+/* request: 0xB2; i: 0; v: 0;
+ * b[0] != 0 -> tune and lock a channel
+ * 0     1     2       3      4      5      6    7
+ * freq0 freq1 divstep srate0 srate1 srate2 flag chksum
+ */
+
+/* one direction requests */
+#define READ_REMOTE_REQ         0xB4
+/* IN  i: 0; v: 0; b[0] == request, b[1] == key */
+
+#define READ_PID_NUMBER_REQ     0xB5
+/* IN  i: 0; v: 0; b[0] == request, b[1] == 0, b[2] = pid number */
+
+#define WRITE_EEPROM_REQ        0xB6
+/* OUT i: offset; v: value to write; no extra buffer */
+
+#define READ_EEPROM_REQ         0xB7
+/* IN  i: bufferlen; v: offset; buffer with bufferlen bytes */
+
+#define READ_STATUS             0xB8
+/* IN  i: 0; v: 0; bufferlen 10 */
+
+#define READ_TUNER_REG_REQ      0xB9
+/* IN  i: 0; v: register; b[0] = value */
+
+#define READ_FX2_REG_REQ        0xBA
+/* IN  i: offset; v: 0; b[0] = value */
+
+#define WRITE_FX2_REG_REQ       0xBB
+/* OUT i: offset; v: value to write; 1 byte extra buffer */
+
+#define SET_TUNER_POWER_REQ     0xBC
+/* IN  i: 0 = power off, 1 = power on */
+
+#define WRITE_TUNER_REG_REQ     0xBD
+/* IN  i: register, v: value to write, no extra buffer */
+
+#define RESET_TUNER             0xBE
+/* IN  i: 0, v: 0, no extra buffer */
+
+struct vp702x_device_state {
+        struct mutex buf_mutex;
+        int buf_len;
+        u8 *buf;
+};
+
+
+extern struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d);
+
+extern int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec);
+extern int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen);
+
+#endif
diff --git a/drivers/media/dvb/dvb-usb/vp7045-fe.c b/drivers/media/dvb/dvb-usb/vp7045-fe.c
new file mode 100644
index 00000000000..8452eef9032
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp7045-fe.c
@@ -0,0 +1,192 @@
+/* DVB frontend part of the Linux driver for TwinhanDTV Alpha/MagicBoxII USB2.0
+ * DVB-T receiver.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ * Thanks to Twinhan who kindly provided hardware and information.
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ *
+ */
+#include "vp7045.h"
+
+/* It is a Zarlink MT352 within a Samsung Tuner (DNOS404ZH102A) - 040929 - AAT
+ *
+ * Programming is hidden inside the firmware, so set_frontend is very easy.
+ * Even though there is a Firmware command that one can use to access the demod
+ * via its registers. This is used for status information.
+ */
+
+struct vp7045_fe_state {
+        struct dvb_frontend fe;
+        struct dvb_usb_device *d;
+};
+
+static int vp7045_fe_read_status(struct dvb_frontend* fe, fe_status_t *status)
+{
+        struct vp7045_fe_state *state = fe->demodulator_priv;
+        u8 s0 = vp7045_read_reg(state->d,0x00),
+           s1 = vp7045_read_reg(state->d,0x01),
+           s3 = vp7045_read_reg(state->d,0x03);
+
+        *status = 0;
+        if (s0 & (1 << 4))
+                *status |= FE_HAS_CARRIER;
+        if (s0 & (1 << 1))
+                *status |= FE_HAS_VITERBI;
+        if (s0 & (1 << 5))
+                *status |= FE_HAS_LOCK;
+        if (s1 & (1 << 1))
+                *status |= FE_HAS_SYNC;
+        if (s3 & (1 << 6))
+                *status |= FE_HAS_SIGNAL;
+
+        if ((*status & (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC)) !=
+                        (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC))
+                *status &= ~FE_HAS_LOCK;
+
+        return 0;
+}
+
+static int vp7045_fe_read_ber(struct dvb_frontend* fe, u32 *ber)
+{
+        struct vp7045_fe_state *state = fe->demodulator_priv;
+        *ber = (vp7045_read_reg(state->d, 0x0D) << 16) |
+               (vp7045_read_reg(state->d, 0x0E) << 8) |
+                vp7045_read_reg(state->d, 0x0F);
+        return 0;
+}
+
+static int vp7045_fe_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
+{
+        struct vp7045_fe_state *state = fe->demodulator_priv;
+        *unc = (vp7045_read_reg(state->d, 0x10) << 8) |
+                    vp7045_read_reg(state->d, 0x11);
+        return 0;
+}
+
+static int vp7045_fe_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
+{
+        struct vp7045_fe_state *state = fe->demodulator_priv;
+        u16 signal = (vp7045_read_reg(state->d, 0x14) << 8) |
+                vp7045_read_reg(state->d, 0x15);
+
+        *strength = ~signal;
+        return 0;
+}
+
+static int vp7045_fe_read_snr(struct dvb_frontend* fe, u16 *snr)
+{
+        struct vp7045_fe_state *state = fe->demodulator_priv;
+        u8 _snr = vp7045_read_reg(state->d, 0x09);
+        *snr = (_snr << 8) | _snr;
+        return 0;
+}
+
+static int vp7045_fe_init(struct dvb_frontend* fe)
+{
+        return 0;
+}
+
+static int vp7045_fe_sleep(struct dvb_frontend* fe)
+{
+        return 0;
+}
+
+static int vp7045_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 800;
+        return 0;
+}
+
+static int vp7045_fe_set_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct vp7045_fe_state *state = fe->demodulator_priv;
+        u8 buf[5];
+        u32 freq = fep->frequency / 1000;
+
+        buf[0] = (freq >> 16) & 0xff;
+        buf[1] = (freq >>  8) & 0xff;
+        buf[2] =  freq        & 0xff;
+        buf[3] = 0;
+
+        switch (fep->u.ofdm.bandwidth) {
+                case BANDWIDTH_8_MHZ: buf[4] = 8; break;
+                case BANDWIDTH_7_MHZ: buf[4] = 7; break;
+                case BANDWIDTH_6_MHZ: buf[4] = 6; break;
+                case BANDWIDTH_AUTO: return -EOPNOTSUPP;
+                default:
+                        return -EINVAL;
+        }
+
+        vp7045_usb_op(state->d,LOCK_TUNER_COMMAND,buf,5,NULL,0,200);
+        return 0;
+}
+
+static int vp7045_fe_get_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        return 0;
+}
+
+static void vp7045_fe_release(struct dvb_frontend* fe)
+{
+        struct vp7045_fe_state *state = fe->demodulator_priv;
+        kfree(state);
+}
+
+static struct dvb_frontend_ops vp7045_fe_ops;
+
+struct dvb_frontend * vp7045_fe_attach(struct dvb_usb_device *d)
+{
+        struct vp7045_fe_state *s = kzalloc(sizeof(struct vp7045_fe_state), GFP_KERNEL);
+        if (s == NULL)
+                goto error;
+
+        s->d = d;
+        memcpy(&s->fe.ops, &vp7045_fe_ops, sizeof(struct dvb_frontend_ops));
+        s->fe.demodulator_priv = s;
+
+        return &s->fe;
+error:
+        return NULL;
+}
+
+
+static struct dvb_frontend_ops vp7045_fe_ops = {
+        .info = {
+                .name                   = "Twinhan VP7045/46 USB DVB-T",
+                .type                   = FE_OFDM,
+                .frequency_min          = 44250000,
+                .frequency_max          = 867250000,
+                .frequency_stepsize     = 1000,
+                .caps = FE_CAN_INVERSION_AUTO |
+                                FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                                FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
+                                FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
+                                FE_CAN_TRANSMISSION_MODE_AUTO |
+                                FE_CAN_GUARD_INTERVAL_AUTO |
+                                FE_CAN_RECOVER |
+                                FE_CAN_HIERARCHY_AUTO,
+        },
+
+        .release = vp7045_fe_release,
+
+        .init = vp7045_fe_init,
+        .sleep = vp7045_fe_sleep,
+
+        .set_frontend = vp7045_fe_set_frontend,
+        .get_frontend = vp7045_fe_get_frontend,
+        .get_tune_settings = vp7045_fe_get_tune_settings,
+
+        .read_status = vp7045_fe_read_status,
+        .read_ber = vp7045_fe_read_ber,
+        .read_signal_strength = vp7045_fe_read_signal_strength,
+        .read_snr = vp7045_fe_read_snr,
+        .read_ucblocks = vp7045_fe_read_unc_blocks,
+};
diff --git a/drivers/media/dvb/dvb-usb/vp7045.c b/drivers/media/dvb/dvb-usb/vp7045.c
new file mode 100644
index 00000000000..536c16c943b
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp7045.c
@@ -0,0 +1,318 @@
+/* DVB USB compliant Linux driver for the
+ *  - TwinhanDTV Alpha/MagicBoxII USB2.0 DVB-T receiver
+ *  - DigitalNow TinyUSB2 DVB-t receiver
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ * Thanks to Twinhan who kindly provided hardware and information.
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "vp7045.h"
+
+/* debug */
+static int dvb_usb_vp7045_debug;
+module_param_named(debug,dvb_usb_vp7045_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+#define deb_info(args...) dprintk(dvb_usb_vp7045_debug,0x01,args)
+#define deb_xfer(args...) dprintk(dvb_usb_vp7045_debug,0x02,args)
+#define deb_rc(args...)   dprintk(dvb_usb_vp7045_debug,0x04,args)
+
+int vp7045_usb_op(struct dvb_usb_device *d, u8 cmd, u8 *out, int outlen, u8 *in, int inlen, int msec)
+{
+        int ret = 0;
+        u8 *buf = d->priv;
+
+        buf[0] = cmd;
+
+        if (outlen > 19)
+                outlen = 19;
+
+        if (inlen > 11)
+                inlen = 11;
+
+        ret = mutex_lock_interruptible(&d->usb_mutex);
+        if (ret)
+                return ret;
+
+        if (out != NULL && outlen > 0)
+                memcpy(&buf[1], out, outlen);
+
+        deb_xfer("out buffer: ");
+        debug_dump(buf, outlen+1, deb_xfer);
+
+
+        if (usb_control_msg(d->udev,
+                        usb_sndctrlpipe(d->udev,0),
+                        TH_COMMAND_OUT, USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0,
+                        buf, 20, 2000) != 20) {
+                err("USB control message 'out' went wrong.");
+                ret = -EIO;
+                goto unlock;
+        }
+
+        msleep(msec);
+
+        if (usb_control_msg(d->udev,
+                        usb_rcvctrlpipe(d->udev,0),
+                        TH_COMMAND_IN, USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
+                        buf, 12, 2000) != 12) {
+                err("USB control message 'in' went wrong.");
+                ret = -EIO;
+                goto unlock;
+        }
+
+        deb_xfer("in buffer: ");
+        debug_dump(buf, 12, deb_xfer);
+
+        if (in != NULL && inlen > 0)
+                memcpy(in, &buf[1], inlen);
+
+unlock:
+        mutex_unlock(&d->usb_mutex);
+
+        return ret;
+}
+
+u8 vp7045_read_reg(struct dvb_usb_device *d, u8 reg)
+{
+        u8 obuf[2] = { 0 },v;
+        obuf[1] = reg;
+
+        vp7045_usb_op(d,TUNER_REG_READ,obuf,2,&v,1,30);
+
+        return v;
+}
+
+static int vp7045_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        u8 v = onoff;
+        return vp7045_usb_op(d,SET_TUNER_POWER,&v,1,NULL,0,150);
+}
+
+/* remote control stuff */
+
+/* The keymapping struct. Somehow this should be loaded to the driver, but
+ * currently it is hardcoded. */
+static struct rc_map_table rc_map_vp7045_table[] = {
+        { 0x0016, KEY_POWER },
+        { 0x0010, KEY_MUTE },
+        { 0x0003, KEY_1 },
+        { 0x0001, KEY_2 },
+        { 0x0006, KEY_3 },
+        { 0x0009, KEY_4 },
+        { 0x001d, KEY_5 },
+        { 0x001f, KEY_6 },
+        { 0x000d, KEY_7 },
+        { 0x0019, KEY_8 },
+        { 0x001b, KEY_9 },
+        { 0x0015, KEY_0 },
+        { 0x0005, KEY_CHANNELUP },
+        { 0x0002, KEY_CHANNELDOWN },
+        { 0x001e, KEY_VOLUMEUP },
+        { 0x000a, KEY_VOLUMEDOWN },
+        { 0x0011, KEY_RECORD },
+        { 0x0017, KEY_FAVORITES }, /* Heart symbol - Channel list. */
+        { 0x0014, KEY_PLAY },
+        { 0x001a, KEY_STOP },
+        { 0x0040, KEY_REWIND },
+        { 0x0012, KEY_FASTFORWARD },
+        { 0x000e, KEY_PREVIOUS }, /* Recall - Previous channel. */
+        { 0x004c, KEY_PAUSE },
+        { 0x004d, KEY_SCREEN }, /* Full screen mode. */
+        { 0x0054, KEY_AUDIO }, /* MTS - Switch to secondary audio. */
+        { 0x000c, KEY_CANCEL }, /* Cancel */
+        { 0x001c, KEY_EPG }, /* EPG */
+        { 0x0000, KEY_TAB }, /* Tab */
+        { 0x0048, KEY_INFO }, /* Preview */
+        { 0x0004, KEY_LIST }, /* RecordList */
+        { 0x000f, KEY_TEXT }, /* Teletext */
+        { 0x0041, KEY_PREVIOUSSONG },
+        { 0x0042, KEY_NEXTSONG },
+        { 0x004b, KEY_UP },
+        { 0x0051, KEY_DOWN },
+        { 0x004e, KEY_LEFT },
+        { 0x0052, KEY_RIGHT },
+        { 0x004f, KEY_ENTER },
+        { 0x0013, KEY_CANCEL },
+        { 0x004a, KEY_CLEAR },
+        { 0x0054, KEY_PRINT }, /* Capture */
+        { 0x0043, KEY_SUBTITLE }, /* Subtitle/CC */
+        { 0x0008, KEY_VIDEO }, /* A/V */
+        { 0x0007, KEY_SLEEP }, /* Hibernate */
+        { 0x0045, KEY_ZOOM }, /* Zoom+ */
+        { 0x0018, KEY_RED},
+        { 0x0053, KEY_GREEN},
+        { 0x005e, KEY_YELLOW},
+        { 0x005f, KEY_BLUE}
+};
+
+static int vp7045_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        u8 key;
+        int i;
+        vp7045_usb_op(d,RC_VAL_READ,NULL,0,&key,1,20);
+
+        deb_rc("remote query key: %x %d\n",key,key);
+
+        if (key == 0x44) {
+                *state = REMOTE_NO_KEY_PRESSED;
+                return 0;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(rc_map_vp7045_table); i++)
+                if (rc5_data(&rc_map_vp7045_table[i]) == key) {
+                        *state = REMOTE_KEY_PRESSED;
+                        *event = rc_map_vp7045_table[i].keycode;
+                        break;
+                }
+        return 0;
+}
+
+static int vp7045_read_eeprom(struct dvb_usb_device *d,u8 *buf, int len, int offset)
+{
+        int i = 0;
+        u8 v,br[2];
+        for (i=0; i < len; i++) {
+                v = offset + i;
+                vp7045_usb_op(d,GET_EE_VALUE,&v,1,br,2,5);
+                buf[i] = br[1];
+        }
+        deb_info("VP7045 EEPROM read (offs: %d, len: %d) : ",offset, i);
+        debug_dump(buf,i,deb_info);
+        return 0;
+}
+
+static int vp7045_read_mac_addr(struct dvb_usb_device *d,u8 mac[6])
+{
+        return vp7045_read_eeprom(d,mac, 6, MAC_0_ADDR);
+}
+
+static int vp7045_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        u8 buf[255] = { 0 };
+
+        vp7045_usb_op(adap->dev,VENDOR_STRING_READ,NULL,0,buf,20,0);
+        buf[10] = '\0';
+        deb_info("firmware says: %s ",buf);
+
+        vp7045_usb_op(adap->dev,PRODUCT_STRING_READ,NULL,0,buf,20,0);
+        buf[10] = '\0';
+        deb_info("%s ",buf);
+
+        vp7045_usb_op(adap->dev,FW_VERSION_READ,NULL,0,buf,20,0);
+        buf[10] = '\0';
+        deb_info("v%s\n",buf);
+
+/*      Dump the EEPROM */
+/*      vp7045_read_eeprom(d,buf, 255, FX2_ID_ADDR); */
+
+        adap->fe = vp7045_fe_attach(adap->dev);
+
+        return 0;
+}
+
+static struct dvb_usb_device_properties vp7045_properties;
+
+static int vp7045_usb_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        return dvb_usb_device_init(intf, &vp7045_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
+}
+
+static struct usb_device_id vp7045_usb_table [] = {
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7045_COLD) },
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7045_WARM) },
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_DNTV_TINYUSB2_COLD) },
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_DNTV_TINYUSB2_WARM) },
+            { 0 },
+};
+MODULE_DEVICE_TABLE(usb, vp7045_usb_table);
+
+static struct dvb_usb_device_properties vp7045_properties = {
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-vp7045-01.fw",
+        .size_of_priv = 20,
+
+        .num_adapters = 1,
+        .adapter = {
+                {
+                        .frontend_attach  = vp7045_frontend_attach,
+                        /* parameter for the MPEG2-data transfer */
+                        .stream = {
+                                .type = USB_BULK,
+                                .count = 7,
+                                .endpoint = 0x02,
+                                .u = {
+                                        .bulk = {
+                                                .buffersize = 4096,
+                                        }
+                                }
+                        },
+                }
+        },
+        .power_ctrl       = vp7045_power_ctrl,
+        .read_mac_address = vp7045_read_mac_addr,
+
+        .rc.legacy = {
+                .rc_interval      = 400,
+                .rc_map_table       = rc_map_vp7045_table,
+                .rc_map_size  = ARRAY_SIZE(rc_map_vp7045_table),
+                .rc_query         = vp7045_rc_query,
+        },
+
+        .num_device_descs = 2,
+        .devices = {
+                { .name = "Twinhan USB2.0 DVB-T receiver (TwinhanDTV Alpha/MagicBox II)",
+                  .cold_ids = { &vp7045_usb_table[0], NULL },
+                  .warm_ids = { &vp7045_usb_table[1], NULL },
+                },
+                { .name = "DigitalNow TinyUSB 2 DVB-t Receiver",
+                  .cold_ids = { &vp7045_usb_table[2], NULL },
+                  .warm_ids = { &vp7045_usb_table[3], NULL },
+                },
+                { NULL },
+        }
+};
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver vp7045_usb_driver = {
+        .name           = "dvb_usb_vp7045",
+        .probe          = vp7045_usb_probe,
+        .disconnect     = dvb_usb_device_exit,
+        .id_table       = vp7045_usb_table,
+};
+
+/* module stuff */
+static int __init vp7045_usb_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&vp7045_usb_driver))) {
+                err("usb_register failed. (%d)",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit vp7045_usb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&vp7045_usb_driver);
+}
+
+module_init(vp7045_usb_module_init);
+module_exit(vp7045_usb_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for Twinhan MagicBox/Alpha and DNTV tinyUSB2 DVB-T USB2.0");
+MODULE_VERSION("1.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/vp7045.h b/drivers/media/dvb/dvb-usb/vp7045.h
new file mode 100644
index 00000000000..cf5ec46f8bb
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp7045.h
@@ -0,0 +1,70 @@
+/* Common header-file of the Linux driver for the TwinhanDTV Alpha/MagicBoxII
+ * USB2.0 DVB-T receiver.
+ *
+ * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
+ *
+ * Thanks to Twinhan who kindly provided hardware and information.
+ *
+ *      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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_VP7045_H_
+#define _DVB_USB_VP7045_H_
+
+#define DVB_USB_LOG_PREFIX "vp7045"
+#include "dvb-usb.h"
+
+/* vp7045 commands */
+
+/* Twinhan Vendor requests */
+#define TH_COMMAND_IN                     0xC0
+#define TH_COMMAND_OUT                    0xC1
+
+/* command bytes */
+#define TUNER_REG_READ                    0x03
+#define TUNER_REG_WRITE                   0x04
+
+#define RC_VAL_READ                       0x05
+ #define RC_NO_KEY                        0x44
+
+#define SET_TUNER_POWER                   0x06
+#define CHECK_TUNER_POWER                 0x12
+ #define Tuner_Power_ON                   1
+ #define Tuner_Power_OFF                  0
+
+#define GET_USB_SPEED                     0x07
+
+#define LOCK_TUNER_COMMAND                0x09
+
+#define TUNER_SIGNAL_READ                 0x0A
+
+/* FX2 eeprom */
+#define SET_EE_VALUE                      0x10
+#define GET_EE_VALUE                      0x11
+ #define FX2_ID_ADDR                      0x00
+ #define VID_MSB_ADDR                     0x02
+ #define VID_LSB_ADDR                     0x01
+ #define PID_MSB_ADDR                     0x04
+ #define PID_LSB_ADDR                     0x03
+ #define MAC_0_ADDR                       0x07
+ #define MAC_1_ADDR                       0x08
+ #define MAC_2_ADDR                       0x09
+ #define MAC_3_ADDR                       0x0a
+ #define MAC_4_ADDR                       0x0b
+ #define MAC_5_ADDR                       0x0c
+
+#define RESET_FX2                         0x13
+
+#define FW_VERSION_READ                   0x0B
+#define VENDOR_STRING_READ                0x0C
+#define PRODUCT_STRING_READ               0x0D
+#define FW_BCD_VERSION_READ               0x14
+
+extern struct dvb_frontend * vp7045_fe_attach(struct dvb_usb_device *d);
+extern int vp7045_usb_op(struct dvb_usb_device *d, u8 cmd, u8 *out, int outlen, u8 *in, int inlen,int msec);
+extern u8 vp7045_read_reg(struct dvb_usb_device *d, u8 reg);
+
+#endif