Merge branch 'linux-2.6' into for-2.6.22

10 files changed, 465 insertions, 289 deletions

diff --git a/drivers/media/dvb/ttpci/Kconfig b/drivers/media/dvb/ttpci/Kconfig
index eec7ccf41f8b..7751628e1415 100644
--- a/drivers/media/dvb/ttpci/Kconfig
+++ b/drivers/media/dvb/ttpci/Kconfig
@@ -3,7 +3,6 @@ config DVB_AV7110
         depends on DVB_CORE && PCI && I2C && VIDEO_V4L1
         select FW_LOADER if !DVB_AV7110_FIRMWARE
         select VIDEO_SAA7146_VV
-        select DVB_PLL
         select DVB_VES1820 if !DVB_FE_CUSTOMISE
         select DVB_VES1X93 if !DVB_FE_CUSTOMISE
         select DVB_STV0299 if !DVB_FE_CUSTOMISE
@@ -62,13 +61,13 @@ config DVB_BUDGET
         tristate "Budget cards"
         depends on DVB_CORE && PCI && I2C && VIDEO_V4L1
         select VIDEO_SAA7146
-        select DVB_PLL
         select DVB_STV0299 if !DVB_FE_CUSTOMISE
         select DVB_VES1X93 if !DVB_FE_CUSTOMISE
         select DVB_VES1820 if !DVB_FE_CUSTOMISE
         select DVB_L64781 if !DVB_FE_CUSTOMISE
         select DVB_TDA8083 if !DVB_FE_CUSTOMISE
         select DVB_TDA10021 if !DVB_FE_CUSTOMISE
+        select DVB_TDA10023 if !DVB_FE_CUSTOMISE
         select DVB_S5H1420 if !DVB_FE_CUSTOMISE
         select DVB_TDA10086 if !DVB_FE_CUSTOMISE
         select DVB_TDA826X if !DVB_FE_CUSTOMISE
@@ -87,7 +86,6 @@ config DVB_BUDGET_CI
         tristate "Budget cards with onboard CI connector"
         depends on DVB_CORE && PCI && I2C && VIDEO_V4L1
         select VIDEO_SAA7146
-        select DVB_PLL
         select DVB_STV0297 if !DVB_FE_CUSTOMISE
         select DVB_STV0299 if !DVB_FE_CUSTOMISE
         select DVB_TDA1004X if !DVB_FE_CUSTOMISE
@@ -114,6 +112,7 @@ config DVB_BUDGET_AV
         select DVB_STV0299 if !DVB_FE_CUSTOMISE
         select DVB_TDA1004X if !DVB_FE_CUSTOMISE
         select DVB_TDA10021 if !DVB_FE_CUSTOMISE
+        select DVB_TDA10023 if !DVB_FE_CUSTOMISE
         select DVB_TUA6100 if !DVB_FE_CUSTOMISE
         select FW_LOADER
         help
@@ -130,7 +129,6 @@ config DVB_BUDGET_PATCH
         tristate "AV7110 cards with Budget Patch"
         depends on DVB_CORE && DVB_BUDGET && VIDEO_V4L1
         select DVB_AV7110
-        select DVB_PLL
         select DVB_STV0299 if !DVB_FE_CUSTOMISE
         select DVB_VES1X93 if !DVB_FE_CUSTOMISE
         select DVB_TDA8083 if !DVB_FE_CUSTOMISE
diff --git a/drivers/media/dvb/ttpci/av7110.c b/drivers/media/dvb/ttpci/av7110.c
index 29ed532ba966..67becdd4db60 100644
--- a/drivers/media/dvb/ttpci/av7110.c
+++ b/drivers/media/dvb/ttpci/av7110.c
@@ -219,7 +219,10 @@ static void recover_arm(struct av7110 *av7110)
                 av7110->recover(av7110);
 
         restart_feeds(av7110);
-        av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, av7110->ir_config);
+
+#if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
+        av7110_check_ir_config(av7110, true);
+#endif
 }
 
 static void av7110_arm_sync(struct av7110 *av7110)
@@ -250,6 +253,10 @@ static int arm_thread(void *data)
                 if (!av7110->arm_ready)
                         continue;
 
+#if defined(CONFIG_INPUT_EVDEV) || defined(CONFIG_INPUT_EVDEV_MODULE)
+                av7110_check_ir_config(av7110, false);
+#endif
+
                 if (mutex_lock_interruptible(&av7110->dcomlock))
                         break;
                 newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
@@ -667,8 +674,8 @@ static void gpioirq(unsigned long data)
                 return;
 
         case DATA_IRCOMMAND:
-                if (av7110->ir_handler)
-                        av7110->ir_handler(av7110,
+                if (av7110->ir.ir_handler)
+                        av7110->ir.ir_handler(av7110,
                                 swahw32(irdebi(av7110, DEBINOSWAP, Reserved, 0, 4)));
                 iwdebi(av7110, DEBINOSWAP, RX_BUFF, 0, 2);
                 break;
@@ -1907,8 +1914,10 @@ static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
         if (av7110->fe_synced == synced)
                 return 0;
 
-        if (av7110->playing)
+        if (av7110->playing) {
+                av7110->fe_synced = synced;
                 return 0;
+        }
 
         if (mutex_lock_interruptible(&av7110->pid_mutex))
                 return -ERESTARTSYS;
diff --git a/drivers/media/dvb/ttpci/av7110.h b/drivers/media/dvb/ttpci/av7110.h
index b98bd453cade..115002b0390c 100644
--- a/drivers/media/dvb/ttpci/av7110.h
+++ b/drivers/media/dvb/ttpci/av7110.h
@@ -5,6 +5,7 @@
 #include <linux/socket.h>
 #include <linux/netdevice.h>
 #include <linux/i2c.h>
+#include <linux/input.h>
 
 #include <linux/dvb/video.h>
 #include <linux/dvb/audio.h>
@@ -66,6 +67,27 @@ struct dvb_video_events {
 };
 
 
+struct av7110;
+
+/* infrared remote control */
+struct infrared {
+        u16     key_map[256];
+        struct input_dev        *input_dev;
+        char                    input_phys[32];
+        struct timer_list       keyup_timer;
+        struct tasklet_struct   ir_tasklet;
+        void                    (*ir_handler)(struct av7110 *av7110, u32 ircom);
+        u32                     ir_command;
+        u32                     ir_config;
+        u32                     device_mask;
+        u8                      protocol;
+        u8                      inversion;
+        u16                     last_key;
+        u16                     last_toggle;
+        u8                      delay_timer_finished;
+};
+
+
 /* place to store all the necessary device information */
 struct av7110 {
 
@@ -227,10 +249,7 @@ struct av7110 {
         u16                     wssMode;
         u16                     wssData;
 
-        u32                     ir_config;
-        u32                     ir_command;
-        void                    (*ir_handler)(struct av7110 *av7110, u32 ircom);
-        struct tasklet_struct   ir_tasklet;
+        struct infrared         ir;
 
         /* firmware stuff */
         unsigned char *bin_fw;
@@ -268,6 +287,7 @@ struct av7110 {
 extern int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
                        u16 subpid, u16 pcrpid);
 
+extern int av7110_check_ir_config(struct av7110 *av7110, int force);
 extern int av7110_ir_init(struct av7110 *av7110);
 extern void av7110_ir_exit(struct av7110 *av7110);
 
diff --git a/drivers/media/dvb/ttpci/av7110_av.c b/drivers/media/dvb/ttpci/av7110_av.c
index e719af807685..654c9e919e04 100644
--- a/drivers/media/dvb/ttpci/av7110_av.c
+++ b/drivers/media/dvb/ttpci/av7110_av.c
@@ -1009,7 +1009,7 @@ static int dvb_video_ioctl(struct inode *inode, struct file *file,
                 if (av7110->videostate.stream_source == VIDEO_SOURCE_MEMORY)
                         ret = av7110_av_stop(av7110, RP_VIDEO);
                 else
-                        ret = vidcom(av7110, VIDEO_CMD_STOP,
+                        ret = vidcom(av7110, AV_VIDEO_CMD_STOP,
                                av7110->videostate.video_blank ? 0 : 1);
                 if (!ret)
                         av7110->trickmode = TRICK_NONE;
@@ -1019,7 +1019,7 @@ static int dvb_video_ioctl(struct inode *inode, struct file *file,
                 av7110->trickmode = TRICK_NONE;
                 if (av7110->videostate.play_state == VIDEO_FREEZED) {
                         av7110->videostate.play_state = VIDEO_PLAYING;
-                        ret = vidcom(av7110, VIDEO_CMD_PLAY, 0);
+                        ret = vidcom(av7110, AV_VIDEO_CMD_PLAY, 0);
                         if (ret)
                                 break;
                 }
@@ -1034,7 +1034,7 @@ static int dvb_video_ioctl(struct inode *inode, struct file *file,
                         ret = av7110_av_start_play(av7110, RP_VIDEO);
                 }
                 if (!ret)
-                        ret = vidcom(av7110, VIDEO_CMD_PLAY, 0);
+                        ret = vidcom(av7110, AV_VIDEO_CMD_PLAY, 0);
                 if (!ret)
                         av7110->videostate.play_state = VIDEO_PLAYING;
                 break;
@@ -1044,7 +1044,7 @@ static int dvb_video_ioctl(struct inode *inode, struct file *file,
                 if (av7110->playing & RP_VIDEO)
                         ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Pause, 0);
                 else
-                        ret = vidcom(av7110, VIDEO_CMD_FREEZE, 1);
+                        ret = vidcom(av7110, AV_VIDEO_CMD_FREEZE, 1);
                 if (!ret)
                         av7110->trickmode = TRICK_FREEZE;
                 break;
@@ -1053,7 +1053,7 @@ static int dvb_video_ioctl(struct inode *inode, struct file *file,
                 if (av7110->playing & RP_VIDEO)
                         ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Continue, 0);
                 if (!ret)
-                        ret = vidcom(av7110, VIDEO_CMD_PLAY, 0);
+                        ret = vidcom(av7110, AV_VIDEO_CMD_PLAY, 0);
                 if (!ret) {
                         av7110->videostate.play_state = VIDEO_PLAYING;
                         av7110->trickmode = TRICK_NONE;
@@ -1136,7 +1136,7 @@ static int dvb_video_ioctl(struct inode *inode, struct file *file,
                         ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
                                             __Scan_I, 2, AV_PES, 0);
                 else
-                        ret = vidcom(av7110, VIDEO_CMD_FFWD, arg);
+                        ret = vidcom(av7110, AV_VIDEO_CMD_FFWD, arg);
                 if (!ret) {
                         av7110->trickmode = TRICK_FAST;
                         av7110->videostate.play_state = VIDEO_PLAYING;
@@ -1147,13 +1147,13 @@ static int dvb_video_ioctl(struct inode *inode, struct file *file,
                 if (av7110->playing&RP_VIDEO) {
                         ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Slow, 2, 0, 0);
                         if (!ret)
-                                ret = vidcom(av7110, VIDEO_CMD_SLOW, arg);
+                                ret = vidcom(av7110, AV_VIDEO_CMD_SLOW, arg);
                 } else {
-                        ret = vidcom(av7110, VIDEO_CMD_PLAY, 0);
+                        ret = vidcom(av7110, AV_VIDEO_CMD_PLAY, 0);
                         if (!ret)
-                                ret = vidcom(av7110, VIDEO_CMD_STOP, 0);
+                                ret = vidcom(av7110, AV_VIDEO_CMD_STOP, 0);
                         if (!ret)
-                                ret = vidcom(av7110, VIDEO_CMD_SLOW, arg);
+                                ret = vidcom(av7110, AV_VIDEO_CMD_SLOW, arg);
                 }
                 if (!ret) {
                         av7110->trickmode = TRICK_SLOW;
@@ -1182,10 +1182,10 @@ static int dvb_video_ioctl(struct inode *inode, struct file *file,
                                 ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
                                                     __Slow, 2, 0, 0);
                                 if (!ret)
-                                        ret = vidcom(av7110, VIDEO_CMD_SLOW, arg);
+                                        ret = vidcom(av7110, AV_VIDEO_CMD_SLOW, arg);
                         }
                         if (av7110->trickmode == TRICK_FREEZE)
-                                ret = vidcom(av7110, VIDEO_CMD_STOP, 1);
+                                ret = vidcom(av7110, AV_VIDEO_CMD_STOP, 1);
                 }
                 break;
 
diff --git a/drivers/media/dvb/ttpci/av7110_hw.h b/drivers/media/dvb/ttpci/av7110_hw.h
index 4e173c67fbb2..673d9b3f064c 100644
--- a/drivers/media/dvb/ttpci/av7110_hw.h
+++ b/drivers/media/dvb/ttpci/av7110_hw.h
@@ -216,11 +216,11 @@ enum av7110_command_type {
 #define VID_CENTRE_CUT_PREF     0x05    /* PanScan with zero vector */
 
 /* MPEG video decoder commands */
-#define VIDEO_CMD_STOP          0x000e
-#define VIDEO_CMD_PLAY          0x000d
-#define VIDEO_CMD_FREEZE        0x0102
-#define VIDEO_CMD_FFWD          0x0016
-#define VIDEO_CMD_SLOW          0x0022
+#define AV_VIDEO_CMD_STOP       0x000e
+#define AV_VIDEO_CMD_PLAY       0x000d
+#define AV_VIDEO_CMD_FREEZE     0x0102
+#define AV_VIDEO_CMD_FFWD       0x0016
+#define AV_VIDEO_CMD_SLOW       0x0022
 
 /* MPEG audio decoder commands */
 #define AUDIO_CMD_MUTE          0x0001
diff --git a/drivers/media/dvb/ttpci/av7110_ir.c b/drivers/media/dvb/ttpci/av7110_ir.c
index f59465bb0af3..a97f166bb523 100644
--- a/drivers/media/dvb/ttpci/av7110_ir.c
+++ b/drivers/media/dvb/ttpci/av7110_ir.c
@@ -1,8 +1,31 @@
+/*
+ * Driver for the remote control of SAA7146 based AV7110 cards
+ *
+ * Copyright (C) 1999-2003 Holger Waechtler <holger@convergence.de>
+ * Copyright (C) 2003-2007 Oliver Endriss <o.endriss@gmx.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; 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.
+ * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
-#include <linux/input.h>
 #include <linux/proc_fs.h>
 #include <linux/kernel.h>
 #include <asm/bitops.h>
@@ -10,18 +33,37 @@
 #include "av7110.h"
 #include "av7110_hw.h"
 
-#define UP_TIMEOUT (HZ*7/25)
 
-/* enable ir debugging by or'ing debug with 16 */
+#define AV_CNT          4
+
+#define IR_RC5          0
+#define IR_RCMM         1
+#define IR_RC5_EXT      2 /* internal only */
+
+#define IR_ALL          0xffffffff
+
+#define UP_TIMEOUT      (HZ*7/25)
 
-static int av_cnt;
-static struct av7110 *av_list[4];
-static struct input_dev *input_dev;
-static char input_phys[32];
 
-static u8 delay_timer_finished;
+/* Note: enable ir debugging by or'ing debug with 16 */
+
+static int ir_protocol[AV_CNT] = { IR_RCMM, IR_RCMM, IR_RCMM, IR_RCMM};
+module_param_array(ir_protocol, int, NULL, 0644);
+MODULE_PARM_DESC(ir_protocol, "Infrared protocol: 0 RC5, 1 RCMM (default)");
+
+static int ir_inversion[AV_CNT];
+module_param_array(ir_inversion, int, NULL, 0644);
+MODULE_PARM_DESC(ir_inversion, "Inversion of infrared signal: 0 not inverted (default), 1 inverted");
+
+static uint ir_device_mask[AV_CNT] = { IR_ALL, IR_ALL, IR_ALL, IR_ALL };
+module_param_array(ir_device_mask, uint, NULL, 0644);
+MODULE_PARM_DESC(ir_device_mask, "Bitmask of infrared devices: bit 0..31 = device 0..31 (default: all)");
+
+
+static int av_cnt;
+static struct av7110 *av_list[AV_CNT];
 
-static u16 key_map [256] = {
+static u16 default_key_map [256] = {
         KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7,
         KEY_8, KEY_9, KEY_BACK, 0, KEY_POWER, KEY_MUTE, 0, KEY_INFO,
         KEY_VOLUMEUP, KEY_VOLUMEDOWN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -45,141 +87,194 @@ static u16 key_map [256] = {
 };
 
 
-static void av7110_emit_keyup(unsigned long data)
+/* key-up timer */
+static void av7110_emit_keyup(unsigned long parm)
 {
-        if (!data || !test_bit(data, input_dev->key))
+        struct infrared *ir = (struct infrared *) parm;
+
+        if (!ir || !test_bit(ir->last_key, ir->input_dev->key))
                 return;
 
-        input_report_key(input_dev, data, 0);
-        input_sync(input_dev);
+        input_report_key(ir->input_dev, ir->last_key, 0);
+        input_sync(ir->input_dev);
 }
 
 
-static struct timer_list keyup_timer = { .function = av7110_emit_keyup };
-
-
+/* tasklet */
 static void av7110_emit_key(unsigned long parm)
 {
-        struct av7110 *av7110 = (struct av7110 *) parm;
-        u32 ir_config = av7110->ir_config;
-        u32 ircom = av7110->ir_command;
+        struct infrared *ir = (struct infrared *) parm;
+        u32 ircom = ir->ir_command;
         u8 data;
         u8 addr;
-        static u16 old_toggle = 0;
-        u16 new_toggle;
+        u16 toggle;
         u16 keycode;
 
         /* extract device address and data */
-        switch (ir_config & 0x0003) {
-        case 0: /* RC5: 5 bits device address, 6 bits data */
+        switch (ir->protocol) {
+        case IR_RC5: /* RC5: 5 bits device address, 6 bits data */
                 data = ircom & 0x3f;
                 addr = (ircom >> 6) & 0x1f;
+                toggle = ircom & 0x0800;
                 break;
 
-        case 1: /* RCMM: 8(?) bits device address, 8(?) bits data */
+        case IR_RCMM: /* RCMM: ? bits device address, ? bits data */
                 data = ircom & 0xff;
-                addr = (ircom >> 8) & 0xff;
+                addr = (ircom >> 8) & 0x1f;
+                toggle = ircom & 0x8000;
                 break;
 
-        case 2: /* extended RC5: 5 bits device address, 7 bits data */
+        case IR_RC5_EXT: /* extended RC5: 5 bits device address, 7 bits data */
                 data = ircom & 0x3f;
                 addr = (ircom >> 6) & 0x1f;
                 /* invert 7th data bit for backward compatibility with RC5 keymaps */
                 if (!(ircom & 0x1000))
                         data |= 0x40;
+                toggle = ircom & 0x0800;
                 break;
 
         default:
-                printk("invalid ir_config %x\n", ir_config);
+                printk("%s invalid protocol %x\n", __FUNCTION__, ir->protocol);
                 return;
         }
 
-        keycode = key_map[data];
+        input_event(ir->input_dev, EV_MSC, MSC_RAW, (addr << 16) | data);
+        input_event(ir->input_dev, EV_MSC, MSC_SCAN, data);
 
-        dprintk(16, "code %08x -> addr %i data 0x%02x -> keycode %i\n",
-                ircom, addr, data, keycode);
+        keycode = ir->key_map[data];
 
-        /* check device address (if selected) */
-        if (ir_config & 0x4000)
-                if (addr != ((ir_config >> 16) & 0xff))
-                        return;
+        dprintk(16, "%s: code %08x -> addr %i data 0x%02x -> keycode %i\n",
+                __FUNCTION__, ircom, addr, data, keycode);
+
+        /* check device address */
+        if (!(ir->device_mask & (1 << addr)))
+                return;
 
         if (!keycode) {
-                printk ("%s: unknown key 0x%02x!!\n", __FUNCTION__, data);
+                printk ("%s: code %08x -> addr %i data 0x%02x -> unknown key!\n",
+                        __FUNCTION__, ircom, addr, data);
                 return;
         }
 
-        if ((ir_config & 0x0003) == 1)
-                new_toggle = 0; /* RCMM */
-        else
-                new_toggle = (ircom & 0x800); /* RC5, extended RC5 */
-
-        if (timer_pending(&keyup_timer)) {
-                del_timer(&keyup_timer);
-                if (keyup_timer.data != keycode || new_toggle != old_toggle) {
-                        delay_timer_finished = 0;
-                        input_event(input_dev, EV_KEY, keyup_timer.data, 0);
-                        input_event(input_dev, EV_KEY, keycode, 1);
-                        input_sync(input_dev);
-                } else if (delay_timer_finished) {
-                        input_event(input_dev, EV_KEY, keycode, 2);
-                        input_sync(input_dev);
+        if (timer_pending(&ir->keyup_timer)) {
+                del_timer(&ir->keyup_timer);
+                if (ir->last_key != keycode || toggle != ir->last_toggle) {
+                        ir->delay_timer_finished = 0;
+                        input_event(ir->input_dev, EV_KEY, ir->last_key, 0);
+                        input_event(ir->input_dev, EV_KEY, keycode, 1);
+                        input_sync(ir->input_dev);
+                } else if (ir->delay_timer_finished) {
+                        input_event(ir->input_dev, EV_KEY, keycode, 2);
+                        input_sync(ir->input_dev);
                 }
         } else {
-                delay_timer_finished = 0;
-                input_event(input_dev, EV_KEY, keycode, 1);
-                input_sync(input_dev);
+                ir->delay_timer_finished = 0;
+                input_event(ir->input_dev, EV_KEY, keycode, 1);
+                input_sync(ir->input_dev);
         }
 
-        keyup_timer.expires = jiffies + UP_TIMEOUT;
-        keyup_timer.data = keycode;
+        ir->last_key = keycode;
+        ir->last_toggle = toggle;
 
-        add_timer(&keyup_timer);
+        ir->keyup_timer.expires = jiffies + UP_TIMEOUT;
+        add_timer(&ir->keyup_timer);
 
-        old_toggle = new_toggle;
 }
 
-static void input_register_keys(void)
+
+/* register with input layer */
+static void input_register_keys(struct infrared *ir)
 {
         int i;
 
-        memset(input_dev->keybit, 0, sizeof(input_dev->keybit));
+        set_bit(EV_KEY, ir->input_dev->evbit);
+        set_bit(EV_REP, ir->input_dev->evbit);
+        set_bit(EV_MSC, ir->input_dev->evbit);
 
-        for (i = 0; i < ARRAY_SIZE(key_map); i++) {
-                if (key_map[i] > KEY_MAX)
-                        key_map[i] = 0;
-                else if (key_map[i] > KEY_RESERVED)
-                        set_bit(key_map[i], input_dev->keybit);
+        set_bit(MSC_RAW, ir->input_dev->mscbit);
+        set_bit(MSC_SCAN, ir->input_dev->mscbit);
+
+        memset(ir->input_dev->keybit, 0, sizeof(ir->input_dev->keybit));
+
+        for (i = 0; i < ARRAY_SIZE(ir->key_map); i++) {
+                if (ir->key_map[i] > KEY_MAX)
+                        ir->key_map[i] = 0;
+                else if (ir->key_map[i] > KEY_RESERVED)
+                        set_bit(ir->key_map[i], ir->input_dev->keybit);
         }
+
+        ir->input_dev->keycode = ir->key_map;
+        ir->input_dev->keycodesize = sizeof(ir->key_map[0]);
+        ir->input_dev->keycodemax = ARRAY_SIZE(ir->key_map);
 }
 
 
-static void input_repeat_key(unsigned long data)
+/* called by the input driver after rep[REP_DELAY] ms */
+static void input_repeat_key(unsigned long parm)
 {
-        /* called by the input driver after rep[REP_DELAY] ms */
-        delay_timer_finished = 1;
+        struct infrared *ir = (struct infrared *) parm;
+
+        ir->delay_timer_finished = 1;
 }
 
 
-static int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
+/* check for configuration changes */
+int av7110_check_ir_config(struct av7110 *av7110, int force)
 {
-        int ret = 0;
+        int i;
+        int modified = force;
+        int ret = -ENODEV;
 
-        dprintk(4, "%p\n", av7110);
-        if (av7110) {
-                ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
-                av7110->ir_config = ir_config;
+        for (i = 0; i < av_cnt; i++)
+                if (av7110 == av_list[i])
+                        break;
+
+        if (i < av_cnt && av7110) {
+                if ((av7110->ir.protocol & 1) != ir_protocol[i] ||
+                    av7110->ir.inversion != ir_inversion[i])
+                        modified = true;
+
+                if (modified) {
+                        /* protocol */
+                        if (ir_protocol[i]) {
+                                ir_protocol[i] = 1;
+                                av7110->ir.protocol = IR_RCMM;
+                                av7110->ir.ir_config = 0x0001;
+                        } else if (FW_VERSION(av7110->arm_app) >= 0x2620) {
+                                av7110->ir.protocol = IR_RC5_EXT;
+                                av7110->ir.ir_config = 0x0002;
+                        } else {
+                                av7110->ir.protocol = IR_RC5;
+                                av7110->ir.ir_config = 0x0000;
+                        }
+                        /* inversion */
+                        if (ir_inversion[i]) {
+                                ir_inversion[i] = 1;
+                                av7110->ir.ir_config |= 0x8000;
+                        }
+                        av7110->ir.inversion = ir_inversion[i];
+                        /* update ARM */
+                        ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1,
+                                                av7110->ir.ir_config);
+                } else
+                        ret = 0;
+
+                /* address */
+                if (av7110->ir.device_mask != ir_device_mask[i])
+                        av7110->ir.device_mask = ir_device_mask[i];
         }
+
         return ret;
 }
 
 
+/* /proc/av7110_ir interface */
 static int av7110_ir_write_proc(struct file *file, const char __user *buffer,
                                 unsigned long count, void *data)
 {
         char *page;
-        int size = 4 + 256 * sizeof(u16);
         u32 ir_config;
+        int size = sizeof ir_config + sizeof av_list[0]->ir.key_map;
         int i;
 
         if (count < size)
@@ -194,71 +289,86 @@ static int av7110_ir_write_proc(struct file *file, const char __user *buffer,
                 return -EFAULT;
         }
 
-        memcpy(&ir_config, page, 4);
-        memcpy(&key_map, page + 4, 256 * sizeof(u16));
+        memcpy(&ir_config, page, sizeof ir_config);
+
+        for (i = 0; i < av_cnt; i++) {
+                /* keymap */
+                memcpy(av_list[i]->ir.key_map, page + sizeof ir_config,
+                        sizeof(av_list[i]->ir.key_map));
+                /* protocol, inversion, address */
+                ir_protocol[i] = ir_config & 0x0001;
+                ir_inversion[i] = ir_config & 0x8000 ? 1 : 0;
+                if (ir_config & 0x4000)
+                        ir_device_mask[i] = 1 << ((ir_config >> 16) & 0x1f);
+                else
+                        ir_device_mask[i] = IR_ALL;
+                /* update configuration */
+                av7110_check_ir_config(av_list[i], false);
+                input_register_keys(&av_list[i]->ir);
+        }
         vfree(page);
-        if (FW_VERSION(av_list[0]->arm_app) >= 0x2620 && !(ir_config & 0x0001))
-                ir_config |= 0x0002; /* enable extended RC5 */
-        for (i = 0; i < av_cnt; i++)
-                av7110_setup_irc_config(av_list[i], ir_config);
-        input_register_keys();
         return count;
 }
 
 
+/* interrupt handler */
 static void ir_handler(struct av7110 *av7110, u32 ircom)
 {
-        dprintk(4, "ircommand = %08x\n", ircom);
-        av7110->ir_command = ircom;
-        tasklet_schedule(&av7110->ir_tasklet);
+        dprintk(4, "ir command = %08x\n", ircom);
+        av7110->ir.ir_command = ircom;
+        tasklet_schedule(&av7110->ir.ir_tasklet);
 }
 
 
 int __devinit av7110_ir_init(struct av7110 *av7110)
 {
+        struct input_dev *input_dev;
         static struct proc_dir_entry *e;
         int err;
 
         if (av_cnt >= ARRAY_SIZE(av_list))
                 return -ENOSPC;
 
-        av7110_setup_irc_config(av7110, 0x0001);
         av_list[av_cnt++] = av7110;
+        av7110_check_ir_config(av7110, true);
 
-        if (av_cnt == 1) {
-                init_timer(&keyup_timer);
-                keyup_timer.data = 0;
-
-                input_dev = input_allocate_device();
-                if (!input_dev)
-                        return -ENOMEM;
-
-                snprintf(input_phys, sizeof(input_phys),
-                        "pci-%s/ir0", pci_name(av7110->dev->pci));
-
-                input_dev->name = "DVB on-card IR receiver";
-
-                input_dev->phys = input_phys;
-                input_dev->id.bustype = BUS_PCI;
-                input_dev->id.version = 1;
-                if (av7110->dev->pci->subsystem_vendor) {
-                        input_dev->id.vendor = av7110->dev->pci->subsystem_vendor;
-                        input_dev->id.product = av7110->dev->pci->subsystem_device;
-                } else {
-                        input_dev->id.vendor = av7110->dev->pci->vendor;
-                        input_dev->id.product = av7110->dev->pci->device;
-                }
-                input_dev->cdev.dev = &av7110->dev->pci->dev;
-                set_bit(EV_KEY, input_dev->evbit);
-                set_bit(EV_REP, input_dev->evbit);
-                input_register_keys();
-                err = input_register_device(input_dev);
-                if (err) {
-                        input_free_device(input_dev);
-                        return err;
-                }
-                input_dev->timer.function = input_repeat_key;
+        init_timer(&av7110->ir.keyup_timer);
+        av7110->ir.keyup_timer.function = av7110_emit_keyup;
+        av7110->ir.keyup_timer.data = (unsigned long) &av7110->ir;
+
+        input_dev = input_allocate_device();
+        if (!input_dev)
+                return -ENOMEM;
 
+        av7110->ir.input_dev = input_dev;
+        snprintf(av7110->ir.input_phys, sizeof(av7110->ir.input_phys),
+                "pci-%s/ir0", pci_name(av7110->dev->pci));
+
+        input_dev->name = "DVB on-card IR receiver";
+
+        input_dev->phys = av7110->ir.input_phys;
+        input_dev->id.bustype = BUS_PCI;
+        input_dev->id.version = 2;
+        if (av7110->dev->pci->subsystem_vendor) {
+                input_dev->id.vendor = av7110->dev->pci->subsystem_vendor;
+                input_dev->id.product = av7110->dev->pci->subsystem_device;
+        } else {
+                input_dev->id.vendor = av7110->dev->pci->vendor;
+                input_dev->id.product = av7110->dev->pci->device;
+        }
+        input_dev->cdev.dev = &av7110->dev->pci->dev;
+        /* initial keymap */
+        memcpy(av7110->ir.key_map, default_key_map, sizeof av7110->ir.key_map);
+        input_register_keys(&av7110->ir);
+        err = input_register_device(input_dev);
+        if (err) {
+                input_free_device(input_dev);
+                return err;
+        }
+        input_dev->timer.function = input_repeat_key;
+        input_dev->timer.data = (unsigned long) &av7110->ir;
+
+        if (av_cnt == 1) {
                 e = create_proc_entry("av7110_ir", S_IFREG | S_IRUGO | S_IWUSR, NULL);
                 if (e) {
                         e->write_proc = av7110_ir_write_proc;
@@ -266,8 +376,8 @@ int __devinit av7110_ir_init(struct av7110 *av7110)
                 }
         }
 
-        tasklet_init(&av7110->ir_tasklet, av7110_emit_key, (unsigned long) av7110);
-        av7110->ir_handler = ir_handler;
+        tasklet_init(&av7110->ir.ir_tasklet, av7110_emit_key, (unsigned long) &av7110->ir);
+        av7110->ir.ir_handler = ir_handler;
 
         return 0;
 }
@@ -280,8 +390,10 @@ void __devexit av7110_ir_exit(struct av7110 *av7110)
         if (av_cnt == 0)
                 return;
 
-        av7110->ir_handler = NULL;
-        tasklet_kill(&av7110->ir_tasklet);
+        del_timer_sync(&av7110->ir.keyup_timer);
+        av7110->ir.ir_handler = NULL;
+        tasklet_kill(&av7110->ir.ir_tasklet);
+
         for (i = 0; i < av_cnt; i++)
                 if (av_list[i] == av7110) {
                         av_list[i] = av_list[av_cnt-1];
@@ -289,14 +401,13 @@ void __devexit av7110_ir_exit(struct av7110 *av7110)
                         break;
                 }
 
-        if (av_cnt == 1) {
-                del_timer_sync(&keyup_timer);
+        if (av_cnt == 1)
                 remove_proc_entry("av7110_ir", NULL);
-                input_unregister_device(input_dev);
-        }
+
+        input_unregister_device(av7110->ir.input_dev);
 
         av_cnt--;
 }
 
-//MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>");
+//MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>, Oliver Endriss <o.endriss@gmx.de>");
 //MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/ttpci/budget-av.c b/drivers/media/dvb/ttpci/budget-av.c
index 3035b224c7a3..0e817d6f1ce5 100644
--- a/drivers/media/dvb/ttpci/budget-av.c
+++ b/drivers/media/dvb/ttpci/budget-av.c
@@ -35,7 +35,7 @@
 
 #include "budget.h"
 #include "stv0299.h"
-#include "tda10021.h"
+#include "tda1002x.h"
 #include "tda1004x.h"
 #include "tua6100.h"
 #include "dvb-pll.h"
@@ -66,9 +66,6 @@ struct budget_av {
         int slot_status;
         struct dvb_ca_en50221 ca;
         u8 reinitialise_demod:1;
-        u8 tda10021_poclkp:1;
-        u8 tda10021_ts_enabled;
-        int (*tda10021_set_frontend)(struct dvb_frontend *fe, struct dvb_frontend_parameters *p);
 };
 
 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot);
@@ -234,12 +231,6 @@ static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
         if (budget_av->reinitialise_demod)
                 dvb_frontend_reinitialise(budget_av->budget.dvb_frontend);
 
-        /* set tda10021 back to original clock configuration on reset */
-        if (budget_av->tda10021_poclkp) {
-                tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
-                budget_av->tda10021_ts_enabled = 0;
-        }
-
         return 0;
 }
 
@@ -256,11 +247,6 @@ static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
         budget_av->slot_status = SLOTSTATUS_NONE;
 
-        /* set tda10021 back to original clock configuration when cam removed */
-        if (budget_av->tda10021_poclkp) {
-                tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
-                budget_av->tda10021_ts_enabled = 0;
-        }
         return 0;
 }
 
@@ -276,12 +262,6 @@ static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
 
         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
 
-        /* tda10021 seems to need a different TS clock config when data is routed to the CAM */
-        if (budget_av->tda10021_poclkp) {
-                tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa1);
-                budget_av->tda10021_ts_enabled = 1;
-        }
-
         return 0;
 }
 
@@ -631,37 +611,62 @@ static struct stv0299_config cinergy_1200s_1894_0010_config = {
 static int philips_cu1216_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         struct budget *budget = (struct budget *) fe->dvb->priv;
-        u8 buf[4];
+        u8 buf[6];
         struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
+        int i;
 
+#define CU1216_IF 36125000
 #define TUNER_MUL 62500
 
-        u32 div = (params->frequency + 36125000 + TUNER_MUL / 2) / TUNER_MUL;
+        u32 div = (params->frequency + CU1216_IF + TUNER_MUL / 2) / TUNER_MUL;
 
         buf[0] = (div >> 8) & 0x7f;
         buf[1] = div & 0xff;
-        buf[2] = 0x86;
+        buf[2] = 0xce;
         buf[3] = (params->frequency < 150000000 ? 0x01 :
                   params->frequency < 445000000 ? 0x02 : 0x04);
+        buf[4] = 0xde;
+        buf[5] = 0x20;
+
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
+        if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
+                return -EIO;
 
+        /* wait for the pll lock */
+        msg.flags = I2C_M_RD;
+        msg.len = 1;
+        for (i = 0; i < 20; i++) {
+                if (fe->ops.i2c_gate_ctrl)
+                        fe->ops.i2c_gate_ctrl(fe, 1);
+                if (i2c_transfer(&budget->i2c_adap, &msg, 1) == 1 && (buf[0] & 0x40))
+                        break;
+                msleep(10);
+        }
+
+        /* switch the charge pump to the lower current */
+        msg.flags = 0;
+        msg.len = 2;
+        msg.buf = &buf[2];
+        buf[2] &= ~0x40;
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
                 return -EIO;
+
         return 0;
 }
 
-static struct tda10021_config philips_cu1216_config = {
+static struct tda1002x_config philips_cu1216_config = {
         .demod_address = 0x0c,
+        .invert = 1,
 };
 
-static struct tda10021_config philips_cu1216_config_altaddress = {
+static struct tda1002x_config philips_cu1216_config_altaddress = {
         .demod_address = 0x0d,
+        .invert = 0,
 };
 
-
-
-
 static int philips_tu1216_tuner_init(struct dvb_frontend *fe)
 {
         struct budget *budget = (struct budget *) fe->dvb->priv;
@@ -908,41 +913,28 @@ static u8 read_pwm(struct budget_av *budget_av)
         return pwm;
 }
 
-#define SUBID_DVBS_KNC1         0x0010
-#define SUBID_DVBS_KNC1_PLUS    0x0011
-#define SUBID_DVBS_TYPHOON      0x4f56
-#define SUBID_DVBS_CINERGY1200  0x1154
-#define SUBID_DVBS_CYNERGY1200N 0x1155
-
-#define SUBID_DVBS_TV_STAR      0x0014
-#define SUBID_DVBS_TV_STAR_CI   0x0016
-#define SUBID_DVBS_EASYWATCH_1  0x001a
-#define SUBID_DVBS_EASYWATCH    0x001e
-#define SUBID_DVBC_EASYWATCH    0x002a
-#define SUBID_DVBC_KNC1         0x0020
-#define SUBID_DVBC_KNC1_PLUS    0x0021
-#define SUBID_DVBC_CINERGY1200  0x1156
-
-#define SUBID_DVBT_KNC1_PLUS    0x0031
-#define SUBID_DVBT_KNC1         0x0030
-#define SUBID_DVBT_CINERGY1200  0x1157
-
-
-static int tda10021_set_frontend(struct dvb_frontend *fe,
-                                 struct dvb_frontend_parameters *p)
-{
-        struct budget_av* budget_av = fe->dvb->priv;
-        int result;
-
-        result = budget_av->tda10021_set_frontend(fe, p);
-        if (budget_av->tda10021_ts_enabled) {
-                tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa1);
-        } else {
-                tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
-        }
-
-        return result;
-}
+#define SUBID_DVBS_KNC1                 0x0010
+#define SUBID_DVBS_KNC1_PLUS            0x0011
+#define SUBID_DVBS_TYPHOON              0x4f56
+#define SUBID_DVBS_CINERGY1200          0x1154
+#define SUBID_DVBS_CYNERGY1200N         0x1155
+#define SUBID_DVBS_TV_STAR              0x0014
+#define SUBID_DVBS_TV_STAR_CI           0x0016
+#define SUBID_DVBS_EASYWATCH_1          0x001a
+#define SUBID_DVBS_EASYWATCH            0x001e
+
+#define SUBID_DVBC_EASYWATCH            0x002a
+#define SUBID_DVBC_EASYWATCH_MK3        0x002c
+#define SUBID_DVBC_KNC1                 0x0020
+#define SUBID_DVBC_KNC1_PLUS            0x0021
+#define SUBID_DVBC_KNC1_MK3             0x0022
+#define SUBID_DVBC_KNC1_PLUS_MK3        0x0023
+#define SUBID_DVBC_CINERGY1200          0x1156
+#define SUBID_DVBC_CINERGY1200_MK3      0x1176
+
+#define SUBID_DVBT_KNC1_PLUS            0x0031
+#define SUBID_DVBT_KNC1                 0x0030
+#define SUBID_DVBT_CINERGY1200          0x1157
 
 static void frontend_init(struct budget_av *budget_av)
 {
@@ -961,6 +953,7 @@ static void frontend_init(struct budget_av *budget_av)
                 case SUBID_DVBC_KNC1_PLUS:
                 case SUBID_DVBT_KNC1_PLUS:
                 case SUBID_DVBC_EASYWATCH:
+                case SUBID_DVBC_KNC1_PLUS_MK3:
                         saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTHI);
                         break;
         }
@@ -1017,6 +1010,7 @@ static void frontend_init(struct budget_av *budget_av)
         case SUBID_DVBC_CINERGY1200:
         case SUBID_DVBC_EASYWATCH:
                 budget_av->reinitialise_demod = 1;
+                budget_av->budget.dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
                 fe = dvb_attach(tda10021_attach, &philips_cu1216_config,
                                      &budget_av->budget.i2c_adap,
                                      read_pwm(budget_av));
@@ -1025,9 +1019,20 @@ static void frontend_init(struct budget_av *budget_av)
                                              &budget_av->budget.i2c_adap,
                                              read_pwm(budget_av));
                 if (fe) {
-                        budget_av->tda10021_poclkp = 1;
-                        budget_av->tda10021_set_frontend = fe->ops.set_frontend;
-                        fe->ops.set_frontend = tda10021_set_frontend;
+                        fe->ops.tuner_ops.set_params = philips_cu1216_tuner_set_params;
+                }
+                break;
+
+        case SUBID_DVBC_EASYWATCH_MK3:
+        case SUBID_DVBC_CINERGY1200_MK3:
+        case SUBID_DVBC_KNC1_MK3:
+        case SUBID_DVBC_KNC1_PLUS_MK3:
+                budget_av->reinitialise_demod = 1;
+                budget_av->budget.dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
+                fe = dvb_attach(tda10023_attach, &philips_cu1216_config,
+                                     &budget_av->budget.i2c_adap,
+                                     read_pwm(budget_av));
+                if (fe) {
                         fe->ops.tuner_ops.set_params = philips_cu1216_tuner_set_params;
                 }
                 break;
@@ -1260,12 +1265,16 @@ MAKE_BUDGET_INFO(kncxs, "KNC TV STAR DVB-S", BUDGET_TVSTAR);
 MAKE_BUDGET_INFO(satewpls, "Satelco EasyWatch DVB-S light", BUDGET_TVSTAR);
 MAKE_BUDGET_INFO(satewpls1, "Satelco EasyWatch DVB-S light", BUDGET_KNC1S);
 MAKE_BUDGET_INFO(satewplc, "Satelco EasyWatch DVB-C", BUDGET_KNC1CP);
+MAKE_BUDGET_INFO(satewcmk3, "Satelco EasyWatch DVB-C MK3", BUDGET_KNC1C_MK3);
 MAKE_BUDGET_INFO(knc1sp, "KNC1 DVB-S Plus", BUDGET_KNC1SP);
 MAKE_BUDGET_INFO(knc1cp, "KNC1 DVB-C Plus", BUDGET_KNC1CP);
+MAKE_BUDGET_INFO(knc1cmk3, "KNC1 DVB-C MK3", BUDGET_KNC1C_MK3);
+MAKE_BUDGET_INFO(knc1cpmk3, "KNC1 DVB-C Plus MK3", BUDGET_KNC1CP_MK3);
 MAKE_BUDGET_INFO(knc1tp, "KNC1 DVB-T Plus", BUDGET_KNC1TP);
 MAKE_BUDGET_INFO(cin1200s, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
 MAKE_BUDGET_INFO(cin1200sn, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
 MAKE_BUDGET_INFO(cin1200c, "Terratec Cinergy 1200 DVB-C", BUDGET_CIN1200C);
+MAKE_BUDGET_INFO(cin1200cmk3, "Terratec Cinergy 1200 DVB-C MK3", BUDGET_CIN1200C_MK3);
 MAKE_BUDGET_INFO(cin1200t, "Terratec Cinergy 1200 DVB-T", BUDGET_CIN1200T);
 
 static struct pci_device_id pci_tbl[] = {
@@ -1279,13 +1288,17 @@ static struct pci_device_id pci_tbl[] = {
         MAKE_EXTENSION_PCI(satewpls, 0x1894, 0x001e),
         MAKE_EXTENSION_PCI(satewpls1, 0x1894, 0x001a),
         MAKE_EXTENSION_PCI(satewplc, 0x1894, 0x002a),
+        MAKE_EXTENSION_PCI(satewcmk3, 0x1894, 0x002c),
         MAKE_EXTENSION_PCI(knc1c, 0x1894, 0x0020),
         MAKE_EXTENSION_PCI(knc1cp, 0x1894, 0x0021),
+        MAKE_EXTENSION_PCI(knc1cmk3, 0x1894, 0x0022),
+        MAKE_EXTENSION_PCI(knc1cpmk3, 0x1894, 0x0023),
         MAKE_EXTENSION_PCI(knc1t, 0x1894, 0x0030),
         MAKE_EXTENSION_PCI(knc1tp, 0x1894, 0x0031),
         MAKE_EXTENSION_PCI(cin1200s, 0x153b, 0x1154),
         MAKE_EXTENSION_PCI(cin1200sn, 0x153b, 0x1155),
         MAKE_EXTENSION_PCI(cin1200c, 0x153b, 0x1156),
+        MAKE_EXTENSION_PCI(cin1200cmk3, 0x153b, 0x1176),
         MAKE_EXTENSION_PCI(cin1200t, 0x153b, 0x1157),
         {
          .vendor = 0,
diff --git a/drivers/media/dvb/ttpci/budget-ci.c b/drivers/media/dvb/ttpci/budget-ci.c
index 464feaf1a9ad..4ed4599ce816 100644
--- a/drivers/media/dvb/ttpci/budget-ci.c
+++ b/drivers/media/dvb/ttpci/budget-ci.c
@@ -73,21 +73,15 @@
 #define SLOTSTATUS_READY        8
 #define SLOTSTATUS_OCCUPIED     (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY)
 
-/* Milliseconds during which key presses are regarded as key repeat and during
- * which the debounce logic is active
+/*
+ * Milliseconds during which a key is regarded as pressed.
+ * If an identical command arrives within this time, the timer will start over.
  */
-#define IR_REPEAT_TIMEOUT       350
+#define IR_KEYPRESS_TIMEOUT     250
 
 /* RC5 device wildcard */
 #define IR_DEVICE_ANY           255
 
-/* Some remotes sends multiple sequences per keypress (e.g. Zenith sends two),
- * this setting allows the superflous sequences to be ignored
- */
-static int debounce = 0;
-module_param(debounce, int, 0644);
-MODULE_PARM_DESC(debounce, "ignore repeated IR sequences (default: 0 = ignore no sequences)");
-
 static int rc5_device = -1;
 module_param(rc5_device, int, 0644);
 MODULE_PARM_DESC(rc5_device, "only IR commands to given RC5 device (device = 0 - 31, any device = 255, default: autodetect)");
@@ -99,10 +93,14 @@ MODULE_PARM_DESC(ir_debug, "enable debugging information for IR decoding");
 struct budget_ci_ir {
         struct input_dev *dev;
         struct tasklet_struct msp430_irq_tasklet;
+        struct timer_list timer_keyup;
         char name[72]; /* 40 + 32 for (struct saa7146_dev).name */
         char phys[32];
         struct ir_input_state state;
         int rc5_device;
+        u32 last_raw;
+        u32 ir_key;
+        bool have_command;
 };
 
 struct budget_ci {
@@ -125,13 +123,8 @@ static void msp430_ir_interrupt(unsigned long data)
 {
         struct budget_ci *budget_ci = (struct budget_ci *) data;
         struct input_dev *dev = budget_ci->ir.dev;
-        static int bounces = 0;
-        int device;
-        int toggle;
-        static int prev_toggle = -1;
-        static u32 ir_key;
-        static int state = 0;
         u32 command = ttpci_budget_debiread(&budget_ci->budget, DEBINOSWAP, DEBIADDR_IR, 2, 1, 0) >> 8;
+        u32 raw;
 
         /*
          * The msp430 chip can generate two different bytes, command and device
@@ -143,7 +136,7 @@ static void msp430_ir_interrupt(unsigned long data)
          * bytes and one or more device bytes. For the repeated bytes, the
          * highest bit (X) is set. The first command byte is always generated
          * before the first device byte. Other than that, no specific order
-         * seems to apply.
+         * seems to apply. To make life interesting, bytes can also be lost.
          *
          * Only when we have a command and device byte, a keypress is
          * generated.
@@ -152,53 +145,35 @@ static void msp430_ir_interrupt(unsigned long data)
         if (ir_debug)
                 printk("budget_ci: received byte 0x%02x\n", command);
 
-        /* Is this a repeated byte? */
-        if (command & 0x80)
-                return;
+        /* Remove repeat bit, we use every command */
+        command = command & 0x7f;
 
         /* Is this a RC5 command byte? */
         if (command & 0x40) {
-                state = 1;
-                ir_key = command & 0x3f;
+                budget_ci->ir.have_command = true;
+                budget_ci->ir.ir_key = command & 0x3f;
                 return;
         }
 
         /* It's a RC5 device byte */
-        if (!state)
+        if (!budget_ci->ir.have_command)
                 return;
-        state = 0;
-        device = command & 0x1f;
-        toggle = command & 0x20;
+        budget_ci->ir.have_command = false;
 
-        if (budget_ci->ir.rc5_device != IR_DEVICE_ANY && budget_ci->ir.rc5_device != device)
+        if (budget_ci->ir.rc5_device != IR_DEVICE_ANY &&
+            budget_ci->ir.rc5_device != (command & 0x1f))
                 return;
 
-        /* Ignore repeated key sequences if requested */
-        if (toggle == prev_toggle && ir_key == dev->repeat_key &&
-            bounces > 0 && timer_pending(&dev->timer)) {
-                if (ir_debug)
-                        printk("budget_ci: debounce logic ignored IR command\n");
-                bounces--;
-                return;
-        }
-        prev_toggle = toggle;
-
-        /* Are we still waiting for a keyup event? */
-        if (del_timer(&dev->timer))
-                ir_input_nokey(dev, &budget_ci->ir.state);
-
-        /* Generate keypress */
-        if (ir_debug)
-                printk("budget_ci: generating keypress 0x%02x\n", ir_key);
-        ir_input_keydown(dev, &budget_ci->ir.state, ir_key, (ir_key & (command << 8)));
-
-        /* Do we want to delay the keyup event? */
-        if (debounce) {
-                bounces = debounce;
-                mod_timer(&dev->timer, jiffies + msecs_to_jiffies(IR_REPEAT_TIMEOUT));
-        } else {
+        /* Is this a repeated key sequence? (same device, command, toggle) */
+        raw = budget_ci->ir.ir_key | (command << 8);
+        if (budget_ci->ir.last_raw != raw || !timer_pending(&budget_ci->ir.timer_keyup)) {
                 ir_input_nokey(dev, &budget_ci->ir.state);
+                ir_input_keydown(dev, &budget_ci->ir.state,
+                                 budget_ci->ir.ir_key, raw);
+                budget_ci->ir.last_raw = raw;
         }
+
+        mod_timer(&budget_ci->ir.timer_keyup, jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT));
 }
 
 static int msp430_ir_init(struct budget_ci *budget_ci)
@@ -271,16 +246,21 @@ static int msp430_ir_init(struct budget_ci *budget_ci)
                 break;
         }
 
-        /* initialise the key-up debounce timeout handler */
-        input_dev->timer.function = msp430_ir_keyup;
-        input_dev->timer.data = (unsigned long) &budget_ci->ir;
-
+        /* initialise the key-up timeout handler */
+        init_timer(&budget_ci->ir.timer_keyup);
+        budget_ci->ir.timer_keyup.function = msp430_ir_keyup;
+        budget_ci->ir.timer_keyup.data = (unsigned long) &budget_ci->ir;
+        budget_ci->ir.last_raw = 0xffff; /* An impossible value */
         error = input_register_device(input_dev);
         if (error) {
                 printk(KERN_ERR "budget_ci: could not init driver for IR device (code %d)\n", error);
                 goto out2;
         }
 
+        /* note: these must be after input_register_device */
+        input_dev->rep[REP_DELAY] = 400;
+        input_dev->rep[REP_PERIOD] = 250;
+
         tasklet_init(&budget_ci->ir.msp430_irq_tasklet, msp430_ir_interrupt,
                      (unsigned long) budget_ci);
 
@@ -304,10 +284,8 @@ static void msp430_ir_deinit(struct budget_ci *budget_ci)
         saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
         tasklet_kill(&budget_ci->ir.msp430_irq_tasklet);
 
-        if (del_timer(&dev->timer)) {
-                ir_input_nokey(dev, &budget_ci->ir.state);
-                input_sync(dev);
-        }
+        del_timer_sync(&dev->timer);
+        ir_input_nokey(dev, &budget_ci->ir.state);
 
         input_unregister_device(dev);
 }
diff --git a/drivers/media/dvb/ttpci/budget-core.c b/drivers/media/dvb/ttpci/budget-core.c
index e15562f81664..6b97dc1e6b65 100644
--- a/drivers/media/dvb/ttpci/budget-core.c
+++ b/drivers/media/dvb/ttpci/budget-core.c
@@ -41,11 +41,14 @@
 
 #define TS_WIDTH                (2 * TS_SIZE)
 #define TS_WIDTH_ACTIVY         TS_SIZE
+#define TS_WIDTH_DVBC           TS_SIZE
 #define TS_HEIGHT_MASK          0xf00
 #define TS_HEIGHT_MASK_ACTIVY   0xc00
+#define TS_HEIGHT_MASK_DVBC     0xe00
 #define TS_MIN_BUFSIZE_K        188
 #define TS_MAX_BUFSIZE_K        1410
 #define TS_MAX_BUFSIZE_K_ACTIVY 564
+#define TS_MAX_BUFSIZE_K_DVBC   1316
 #define BUFFER_WARNING_WAIT     (30*HZ)
 
 int budget_debug;
@@ -106,6 +109,19 @@ static int start_ts_capture(struct budget *budget)
                 saa7146_write(dev, MC2, (MASK_10 | MASK_26));
                 saa7146_write(dev, BRS_CTRL, 0x60000000);
                 break;
+        case BUDGET_CIN1200C_MK3:
+        case BUDGET_KNC1C_MK3:
+        case BUDGET_KNC1CP_MK3:
+                if (budget->video_port == BUDGET_VIDEO_PORTA) {
+                        saa7146_write(dev, DD1_INIT, 0x06000200);
+                        saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
+                        saa7146_write(dev, BRS_CTRL, 0x00000000);
+                } else {
+                        saa7146_write(dev, DD1_INIT, 0x00000600);
+                        saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
+                        saa7146_write(dev, BRS_CTRL, 0x60000000);
+                }
+                break;
         default:
                 if (budget->video_port == BUDGET_VIDEO_PORTA) {
                         saa7146_write(dev, DD1_INIT, 0x06000200);
@@ -122,7 +138,13 @@ static int start_ts_capture(struct budget *budget)
         mdelay(10);
 
         saa7146_write(dev, BASE_ODD3, 0);
-        saa7146_write(dev, BASE_EVEN3, 0);
+        if (budget->buffer_size > budget->buffer_height * budget->buffer_width) {
+                // using odd/even buffers
+                saa7146_write(dev, BASE_EVEN3, budget->buffer_height * budget->buffer_width);
+        } else {
+                // using a single buffer
+                saa7146_write(dev, BASE_EVEN3, 0);
+        }
         saa7146_write(dev, PROT_ADDR3, budget->buffer_size);
         saa7146_write(dev, BASE_PAGE3, budget->pt.dma | ME1 | 0x90);
 
@@ -399,11 +421,25 @@ int ttpci_budget_init(struct budget *budget, struct saa7146_dev *dev,
         budget->card = bi;
         budget->dev = (struct saa7146_dev *) dev;
 
-        if (budget->card->type == BUDGET_FS_ACTIVY) {
+        switch(budget->card->type) {
+        case BUDGET_FS_ACTIVY:
                 budget->buffer_width = TS_WIDTH_ACTIVY;
                 max_bufsize = TS_MAX_BUFSIZE_K_ACTIVY;
                 height_mask = TS_HEIGHT_MASK_ACTIVY;
-        } else {
+                break;
+
+        case BUDGET_KNC1C:
+        case BUDGET_KNC1CP:
+        case BUDGET_CIN1200C:
+        case BUDGET_KNC1C_MK3:
+        case BUDGET_KNC1CP_MK3:
+        case BUDGET_CIN1200C_MK3:
+                budget->buffer_width = TS_WIDTH_DVBC;
+                max_bufsize = TS_MAX_BUFSIZE_K_DVBC;
+                height_mask = TS_HEIGHT_MASK_DVBC;
+                break;
+
+        default:
                 budget->buffer_width = TS_WIDTH;
                 max_bufsize = TS_MAX_BUFSIZE_K;
                 height_mask = TS_HEIGHT_MASK;
@@ -415,14 +451,22 @@ int ttpci_budget_init(struct budget *budget, struct saa7146_dev *dev,
                 dma_buffer_size = max_bufsize;
 
         budget->buffer_height = dma_buffer_size * 1024 / budget->buffer_width;
-        budget->buffer_height &= height_mask;
-        budget->buffer_size = budget->buffer_height * budget->buffer_width;
+        if (budget->buffer_height > 0xfff) {
+                budget->buffer_height /= 2;
+                budget->buffer_height &= height_mask;
+                budget->buffer_size = 2 * budget->buffer_height * budget->buffer_width;
+        } else {
+                budget->buffer_height &= height_mask;
+                budget->buffer_size = budget->buffer_height * budget->buffer_width;
+        }
         budget->buffer_warning_threshold = budget->buffer_size * 80/100;
         budget->buffer_warnings = 0;
         budget->buffer_warning_time = jiffies;
 
-        dprintk(2, "%s: width = %d, height = %d\n",
-                budget->dev->name, budget->buffer_width, budget->buffer_height);
+        dprintk(2, "%s: buffer type = %s, width = %d, height = %d\n",
+                budget->dev->name,
+                budget->buffer_size > budget->buffer_width * budget->buffer_height ? "odd/even" : "single",
+                budget->buffer_width, budget->buffer_height);
         printk("%s: dma buffer size %u\n", budget->dev->name, budget->buffer_size);
 
         if ((ret = dvb_register_adapter(&budget->dvb_adapter, budget->card->name, owner, &budget->dev->pci->dev)) < 0) {
diff --git a/drivers/media/dvb/ttpci/budget.h b/drivers/media/dvb/ttpci/budget.h
index e8a5c79178e1..d764ffa728b0 100644
--- a/drivers/media/dvb/ttpci/budget.h
+++ b/drivers/media/dvb/ttpci/budget.h
@@ -99,6 +99,9 @@ static struct saa7146_pci_extension_data x_var = { \
 #define BUDGET_KNC1CP              12
 #define BUDGET_KNC1TP              13
 #define BUDGET_TVSTAR              14
+#define BUDGET_CIN1200C_MK3        15
+#define BUDGET_KNC1C_MK3           16
+#define BUDGET_KNC1CP_MK3          17
 
 #define BUDGET_VIDEO_PORTA         0
 #define BUDGET_VIDEO_PORTB         1