84 files changed, 1547 insertions, 2409 deletions
diff --git a/drivers/Makefile b/drivers/Makefile
index 619dd964c51c..5c69b86db624 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -69,7 +69,7 @@ obj-$(CONFIG_EISA)		+= eisa/
 obj-$(CONFIG_CPU_FREQ)          += cpufreq/
 obj-$(CONFIG_MMC)               += mmc/
 obj-$(CONFIG_INFINIBAND)        += infiniband/
-obj-$(CONFIG_SGI_IOC4)          += sn/
+obj-$(CONFIG_SGI_SN)            += sn/
 obj-y                           += firmware/
 obj-$(CONFIG_CRYPTO)            += crypto/
 obj-$(CONFIG_SUPERH)            += sh/
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 12d7b9bdfa93..0d65394707db 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -2183,6 +2183,7 @@ static void cciss_softirq_done(struct request *rq)
 {
        CommandList_struct *cmd = rq->completion_data;
        ctlr_info_t *h = hba[cmd->ctlr];
+        unsigned long flags;
        u64bit temp64;
        int i, ddir;
@@ -2205,10 +2206,10 @@ static void cciss_softirq_done(struct request *rq)
        printk("Done with %p\n", rq);
 #endif /* CCISS_DEBUG */ 
-        spin_lock_irq(&h->lock);
+        spin_lock_irqsave(&h->lock, flags);
        end_that_request_last(rq, rq->errors);
        cmd_free(h, cmd,1);
-        spin_unlock_irq(&h->lock);
+        spin_unlock_irqrestore(&h->lock, flags);
 }
 /* checks the status of the job and calls complete buffers to mark all 
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index c58295914365..7230d4e08196 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -113,6 +113,16 @@ config SENSORS_DS1621
          This driver can also be built as a module.  If so, the module
          will be called ds1621.
+config SENSORS_F71805F
+        tristate "Fintek F71805F/FG"
+        depends on HWMON && EXPERIMENTAL
+        help
+          If you say yes here you get support for hardware monitoring
+          features of the Fintek F71805F/FG chips.
+          This driver can also be built as a module.  If so, the module
+          will be called f71805f.
 config SENSORS_FSCHER
        tristate "FSC Hermes"
        depends on HWMON && I2C && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 06d4a1d14105..fbdb8d911a72 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -18,6 +18,7 @@ obj-$(CONFIG_SENSORS_ADM1031)	+= adm1031.o
 obj-$(CONFIG_SENSORS_ADM9240)   += adm9240.o
 obj-$(CONFIG_SENSORS_ATXP1)     += atxp1.o
 obj-$(CONFIG_SENSORS_DS1621)    += ds1621.o
+obj-$(CONFIG_SENSORS_F71805F)   += f71805f.o
 obj-$(CONFIG_SENSORS_FSCHER)    += fscher.o
 obj-$(CONFIG_SENSORS_FSCPOS)    += fscpos.o
 obj-$(CONFIG_SENSORS_GL518SM)   += gl518sm.o
diff --git a/drivers/hwmon/f71805f.c b/drivers/hwmon/f71805f.c
new file mode 100644
index 000000000000..e029e0a94ecc
--- /dev/null
+++ b/drivers/hwmon/f71805f.c
@@ -0,0 +1,908 @@
+/*
+ * f71805f.c - driver for the Fintek F71805F/FG Super-I/O chip integrated
+ *             hardware monitoring features
+ * Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
+ *
+ * The F71805F/FG is a LPC Super-I/O chip made by Fintek. It integrates
+ * complete hardware monitoring features: voltage, fan and temperature
+ * sensors, and manual and automatic fan speed control.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/platform_device.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <asm/io.h>
+static struct platform_device *pdev;
+#define DRVNAME "f71805f"
+/*
+ * Super-I/O constants and functions
+ */
+#define F71805F_LD_HWM          0x04
+#define SIO_REG_LDSEL           0x07    /* Logical device select */
+#define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
+#define SIO_REG_DEVREV          0x22    /* Device revision */
+#define SIO_REG_MANID           0x23    /* Fintek ID (2 bytes) */
+#define SIO_REG_ENABLE          0x30    /* Logical device enable */
+#define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
+#define SIO_FINTEK_ID           0x1934
+#define SIO_F71805F_ID          0x0406
+static inline int
+superio_inb(int base, int reg)
+{
+        outb(reg, base);
+        return inb(base + 1);
+}
+static int
+superio_inw(int base, int reg)
+{
+        int val;
+        outb(reg++, base);
+        val = inb(base + 1) << 8;
+        outb(reg, base);
+        val |= inb(base + 1);
+        return val;
+}
+static inline void
+superio_select(int base, int ld)
+{
+        outb(SIO_REG_LDSEL, base);
+        outb(ld, base + 1);
+}
+static inline void
+superio_enter(int base)
+{
+        outb(0x87, base);
+        outb(0x87, base);
+}
+static inline void
+superio_exit(int base)
+{
+        outb(0xaa, base);
+}
+/*
+ * ISA constants
+ */
+#define REGION_LENGTH           2
+#define ADDR_REG_OFFSET         0
+#define DATA_REG_OFFSET         1
+static struct resource f71805f_resource __initdata = {
+        .flags  = IORESOURCE_IO,
+};
+/*
+ * Registers
+ */
+/* in nr from 0 to 8 (8-bit values) */
+#define F71805F_REG_IN(nr)              (0x10 + (nr))
+#define F71805F_REG_IN_HIGH(nr)         (0x40 + 2 * (nr))
+#define F71805F_REG_IN_LOW(nr)          (0x41 + 2 * (nr))
+/* fan nr from 0 to 2 (12-bit values, two registers) */
+#define F71805F_REG_FAN(nr)             (0x20 + 2 * (nr))
+#define F71805F_REG_FAN_LOW(nr)         (0x28 + 2 * (nr))
+#define F71805F_REG_FAN_CTRL(nr)        (0x60 + 16 * (nr))
+/* temp nr from 0 to 2 (8-bit values) */
+#define F71805F_REG_TEMP(nr)            (0x1B + (nr))
+#define F71805F_REG_TEMP_HIGH(nr)       (0x54 + 2 * (nr))
+#define F71805F_REG_TEMP_HYST(nr)       (0x55 + 2 * (nr))
+#define F71805F_REG_TEMP_MODE           0x01
+#define F71805F_REG_START               0x00
+/* status nr from 0 to 2 */
+#define F71805F_REG_STATUS(nr)          (0x36 + (nr))
+/*
+ * Data structures and manipulation thereof
+ */
+struct f71805f_data {
+        unsigned short addr;
+        const char *name;
+        struct semaphore lock;
+        struct class_device *class_dev;
+        struct semaphore update_lock;
+        char valid;             /* !=0 if following fields are valid */
+        unsigned long last_updated;     /* In jiffies */
+        unsigned long last_limits;      /* In jiffies */
+        /* Register values */
+        u8 in[9];
+        u8 in_high[9];
+        u8 in_low[9];
+        u16 fan[3];
+        u16 fan_low[3];
+        u8 fan_enabled;         /* Read once at init time */
+        u8 temp[3];
+        u8 temp_high[3];
+        u8 temp_hyst[3];
+        u8 temp_mode;
+        u8 alarms[3];
+};
+static inline long in_from_reg(u8 reg)
+{
+        return (reg * 8);
+}
+/* The 2 least significant bits are not used */
+static inline u8 in_to_reg(long val)
+{
+        if (val <= 0)
+                return 0;
+        if (val >= 2016)
+                return 0xfc;
+        return (((val + 16) / 32) << 2);
+}
+/* in0 is downscaled by a factor 2 internally */
+static inline long in0_from_reg(u8 reg)
+{
+        return (reg * 16);
+}
+static inline u8 in0_to_reg(long val)
+{
+        if (val <= 0)
+                return 0;
+        if (val >= 4032)
+                return 0xfc;
+        return (((val + 32) / 64) << 2);
+}
+/* The 4 most significant bits are not used */
+static inline long fan_from_reg(u16 reg)
+{
+        reg &= 0xfff;
+        if (!reg || reg == 0xfff)
+                return 0;
+        return (1500000 / reg);
+}
+static inline u16 fan_to_reg(long rpm)
+{
+        /* If the low limit is set below what the chip can measure,
+           store the largest possible 12-bit value in the registers,
+           so that no alarm will ever trigger. */
+        if (rpm < 367)
+                return 0xfff;
+        return (1500000 / rpm);
+}
+static inline long temp_from_reg(u8 reg)
+{
+        return (reg * 1000);
+}
+static inline u8 temp_to_reg(long val)
+{
+        if (val < 0)
+                val = 0;
+        else if (val > 1000 * 0xff)
+                val = 0xff;
+        return ((val + 500) / 1000);
+}
+/*
+ * Device I/O access
+ */
+static u8 f71805f_read8(struct f71805f_data *data, u8 reg)
+{
+        u8 val;
+        down(&data->lock);
+        outb(reg, data->addr + ADDR_REG_OFFSET);
+        val = inb(data->addr + DATA_REG_OFFSET);
+        up(&data->lock);
+        return val;
+}
+static void f71805f_write8(struct f71805f_data *data, u8 reg, u8 val)
+{
+        down(&data->lock);
+        outb(reg, data->addr + ADDR_REG_OFFSET);
+        outb(val, data->addr + DATA_REG_OFFSET);
+        up(&data->lock);
+}
+/* It is important to read the MSB first, because doing so latches the
+   value of the LSB, so we are sure both bytes belong to the same value. */
+static u16 f71805f_read16(struct f71805f_data *data, u8 reg)
+{
+        u16 val;
+        down(&data->lock);
+        outb(reg, data->addr + ADDR_REG_OFFSET);
+        val = inb(data->addr + DATA_REG_OFFSET) << 8;
+        outb(++reg, data->addr + ADDR_REG_OFFSET);
+        val |= inb(data->addr + DATA_REG_OFFSET);
+        up(&data->lock);
+        return val;
+}
+static void f71805f_write16(struct f71805f_data *data, u8 reg, u16 val)
+{
+        down(&data->lock);
+        outb(reg, data->addr + ADDR_REG_OFFSET);
+        outb(val >> 8, data->addr + DATA_REG_OFFSET);
+        outb(++reg, data->addr + ADDR_REG_OFFSET);
+        outb(val & 0xff, data->addr + DATA_REG_OFFSET);
+        up(&data->lock);
+}
+static struct f71805f_data *f71805f_update_device(struct device *dev)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        int nr;
+        down(&data->update_lock);
+        /* Limit registers cache is refreshed after 60 seconds */
+        if (time_after(jiffies, data->last_updated + 60 * HZ)
+         || !data->valid) {
+                for (nr = 0; nr < 9; nr++) {
+                        data->in_high[nr] = f71805f_read8(data,
+                                            F71805F_REG_IN_HIGH(nr));
+                        data->in_low[nr] = f71805f_read8(data,
+                                           F71805F_REG_IN_LOW(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        if (data->fan_enabled & (1 << nr))
+                                data->fan_low[nr] = f71805f_read16(data,
+                                                    F71805F_REG_FAN_LOW(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        data->temp_high[nr] = f71805f_read8(data,
+                                              F71805F_REG_TEMP_HIGH(nr));
+                        data->temp_hyst[nr] = f71805f_read8(data,
+                                              F71805F_REG_TEMP_HYST(nr));
+                }
+                data->temp_mode = f71805f_read8(data, F71805F_REG_TEMP_MODE);
+                data->last_limits = jiffies;
+        }
+        /* Measurement registers cache is refreshed after 1 second */
+        if (time_after(jiffies, data->last_updated + HZ)
+         || !data->valid) {
+                for (nr = 0; nr < 9; nr++) {
+                        data->in[nr] = f71805f_read8(data,
+                                       F71805F_REG_IN(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        if (data->fan_enabled & (1 << nr))
+                                data->fan[nr] = f71805f_read16(data,
+                                                F71805F_REG_FAN(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        data->temp[nr] = f71805f_read8(data,
+                                         F71805F_REG_TEMP(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        data->alarms[nr] = f71805f_read8(data,
+                                           F71805F_REG_STATUS(nr));
+                }
+                data->last_updated = jiffies;
+                data->valid = 1;
+        }
+        up(&data->update_lock);
+        return data;
+}
+/*
+ * Sysfs interface
+ */
+static ssize_t show_in0(struct device *dev, struct device_attribute *devattr,
+                        char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        return sprintf(buf, "%ld\n", in0_from_reg(data->in[0]));
+}
+static ssize_t show_in0_max(struct device *dev, struct device_attribute
+                            *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        return sprintf(buf, "%ld\n", in0_from_reg(data->in_high[0]));
+}
+static ssize_t show_in0_min(struct device *dev, struct device_attribute
+                            *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        return sprintf(buf, "%ld\n", in0_from_reg(data->in_low[0]));
+}
+static ssize_t set_in0_max(struct device *dev, struct device_attribute
+                           *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        long val = simple_strtol(buf, NULL, 10);
+        down(&data->update_lock);
+        data->in_high[0] = in0_to_reg(val);
+        f71805f_write8(data, F71805F_REG_IN_HIGH(0), data->in_high[0]);
+        up(&data->update_lock);
+        return count;
+}
+static ssize_t set_in0_min(struct device *dev, struct device_attribute
+                           *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        long val = simple_strtol(buf, NULL, 10);
+        down(&data->update_lock);
+        data->in_low[0] = in0_to_reg(val);
+        f71805f_write8(data, F71805F_REG_IN_LOW(0), data->in_low[0]);
+        up(&data->update_lock);
+        return count;
+}
+static DEVICE_ATTR(in0_input, S_IRUGO, show_in0, NULL);
+static DEVICE_ATTR(in0_max, S_IRUGO| S_IWUSR, show_in0_max, set_in0_max);
+static DEVICE_ATTR(in0_min, S_IRUGO| S_IWUSR, show_in0_min, set_in0_min);
+static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
+                       char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        return sprintf(buf, "%ld\n", in_from_reg(data->in[nr]));
+}
+static ssize_t show_in_max(struct device *dev, struct device_attribute
+                           *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        return sprintf(buf, "%ld\n", in_from_reg(data->in_high[nr]));
+}
+static ssize_t show_in_min(struct device *dev, struct device_attribute
+                           *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        return sprintf(buf, "%ld\n", in_from_reg(data->in_low[nr]));
+}
+static ssize_t set_in_max(struct device *dev, struct device_attribute
+                          *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+        down(&data->update_lock);
+        data->in_high[nr] = in_to_reg(val);
+        f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]);
+        up(&data->update_lock);
+        return count;
+}
+static ssize_t set_in_min(struct device *dev, struct device_attribute
+                          *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+        down(&data->update_lock);
+        data->in_low[nr] = in_to_reg(val);
+        f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]);
+        up(&data->update_lock);
+        return count;
+}
+#define sysfs_in(offset)                                        \
+static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
+                show_in, NULL, offset);                         \
+static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
+                show_in_max, set_in_max, offset);               \
+static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
+                show_in_min, set_in_min, offset)
+sysfs_in(1);
+sysfs_in(2);
+sysfs_in(3);
+sysfs_in(4);
+sysfs_in(5);
+sysfs_in(6);
+sysfs_in(7);
+sysfs_in(8);
+static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
+                        char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        return sprintf(buf, "%ld\n", fan_from_reg(data->fan[nr]));
+}
+static ssize_t show_fan_min(struct device *dev, struct device_attribute
+                            *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        return sprintf(buf, "%ld\n", fan_from_reg(data->fan_low[nr]));
+}
+static ssize_t set_fan_min(struct device *dev, struct device_attribute
+                           *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+        down(&data->update_lock);
+        data->fan_low[nr] = fan_to_reg(val);
+        f71805f_write16(data, F71805F_REG_FAN_LOW(nr), data->fan_low[nr]);
+        up(&data->update_lock);
+        return count;
+}
+#define sysfs_fan(offset)                                       \
+static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
+                show_fan, NULL, offset - 1);                    \
+static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
+                show_fan_min, set_fan_min, offset - 1)
+sysfs_fan(1);
+sysfs_fan(2);
+sysfs_fan(3);
+static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
+                         char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
+}
+static ssize_t show_temp_max(struct device *dev, struct device_attribute
+                             *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        return sprintf(buf, "%ld\n", temp_from_reg(data->temp_high[nr]));
+}
+static ssize_t show_temp_hyst(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        return sprintf(buf, "%ld\n", temp_from_reg(data->temp_hyst[nr]));
+}
+static ssize_t show_temp_type(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        /* 3 is diode, 4 is thermistor */
+        return sprintf(buf, "%u\n", (data->temp_mode & (1 << nr)) ? 3 : 4);
+}
+static ssize_t set_temp_max(struct device *dev, struct device_attribute
+                            *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+        down(&data->update_lock);
+        data->temp_high[nr] = temp_to_reg(val);
+        f71805f_write8(data, F71805F_REG_TEMP_HIGH(nr), data->temp_high[nr]);
+        up(&data->update_lock);
+        return count;
+}
+static ssize_t set_temp_hyst(struct device *dev, struct device_attribute
+                             *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+        down(&data->update_lock);
+        data->temp_hyst[nr] = temp_to_reg(val);
+        f71805f_write8(data, F71805F_REG_TEMP_HYST(nr), data->temp_hyst[nr]);
+        up(&data->update_lock);
+        return count;
+}
+#define sysfs_temp(offset)                                              \
+static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
+                show_temp, NULL, offset - 1);                           \
+static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
+                show_temp_max, set_temp_max, offset - 1);               \
+static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR,   \
+                show_temp_hyst, set_temp_hyst, offset - 1);             \
+static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO,                 \
+                show_temp_type, NULL, offset - 1)
+sysfs_temp(1);
+sysfs_temp(2);
+sysfs_temp(3);
+static ssize_t show_alarms_in(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        return sprintf(buf, "%d\n", data->alarms[0] |
+                                    ((data->alarms[1] & 0x01) << 8));
+}
+static ssize_t show_alarms_fan(struct device *dev, struct device_attribute
+                               *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        return sprintf(buf, "%d\n", data->alarms[2] & 0x07);
+}
+static ssize_t show_alarms_temp(struct device *dev, struct device_attribute
+                                *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        return sprintf(buf, "%d\n", (data->alarms[1] >> 3) & 0x07);
+}
+static DEVICE_ATTR(alarms_in, S_IRUGO, show_alarms_in, NULL);
+static DEVICE_ATTR(alarms_fan, S_IRUGO, show_alarms_fan, NULL);
+static DEVICE_ATTR(alarms_temp, S_IRUGO, show_alarms_temp, NULL);
+static ssize_t show_name(struct device *dev, struct device_attribute
+                         *devattr, char *buf)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+/*
+ * Device registration and initialization
+ */
+static void __devinit f71805f_init_device(struct f71805f_data *data)
+{
+        u8 reg;
+        int i;
+        reg = f71805f_read8(data, F71805F_REG_START);
+        if ((reg & 0x41) != 0x01) {
+                printk(KERN_DEBUG DRVNAME ": Starting monitoring "
+                       "operations\n");
+                f71805f_write8(data, F71805F_REG_START, (reg | 0x01) & ~0x40);
+        }
+        /* Fan monitoring can be disabled. If it is, we won't be polling
+           the register values, and won't create the related sysfs files. */
+        for (i = 0; i < 3; i++) {
+                reg = f71805f_read8(data, F71805F_REG_FAN_CTRL(i));
+                if (!(reg & 0x80))
+                        data->fan_enabled |= (1 << i);
+        }
+}
+static int __devinit f71805f_probe(struct platform_device *pdev)
+{
+        struct f71805f_data *data;
+        struct resource *res;
+        int err;
+        if (!(data = kzalloc(sizeof(struct f71805f_data), GFP_KERNEL))) {
+                err = -ENOMEM;
+                printk(KERN_ERR DRVNAME ": Out of memory\n");
+                goto exit;
+        }
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        data->addr = res->start;
+        init_MUTEX(&data->lock);
+        data->name = "f71805f";
+        init_MUTEX(&data->update_lock);
+        platform_set_drvdata(pdev, data);
+        data->class_dev = hwmon_device_register(&pdev->dev);
+        if (IS_ERR(data->class_dev)) {
+                err = PTR_ERR(data->class_dev);
+                dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
+                goto exit_free;
+        }
+        /* Initialize the F71805F chip */
+        f71805f_init_device(data);
+        /* Register sysfs interface files */
+        device_create_file(&pdev->dev, &dev_attr_in0_input);
+        device_create_file(&pdev->dev, &dev_attr_in0_max);
+        device_create_file(&pdev->dev, &dev_attr_in0_min);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in1_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in2_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in3_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in4_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in5_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in6_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in7_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in8_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in1_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in2_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in3_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in4_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in5_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in6_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in7_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in8_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in1_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in2_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in3_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in4_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in5_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in6_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in7_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in8_min.dev_attr);
+        if (data->fan_enabled & (1 << 0)) {
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan1_input.dev_attr);
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan1_min.dev_attr);
+        }
+        if (data->fan_enabled & (1 << 1)) {
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan2_input.dev_attr);
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan2_min.dev_attr);
+        }
+        if (data->fan_enabled & (1 << 2)) {
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan3_input.dev_attr);
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan3_min.dev_attr);
+        }
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp1_input.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp2_input.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp3_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp2_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp3_max.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp1_max_hyst.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp2_max_hyst.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp3_max_hyst.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp1_type.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp2_type.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp3_type.dev_attr);
+        device_create_file(&pdev->dev, &dev_attr_alarms_in);
+        device_create_file(&pdev->dev, &dev_attr_alarms_fan);
+        device_create_file(&pdev->dev, &dev_attr_alarms_temp);
+        device_create_file(&pdev->dev, &dev_attr_name);
+        return 0;
+exit_free:
+        kfree(data);
+exit:
+        return err;
+}
+static int __devexit f71805f_remove(struct platform_device *pdev)
+{
+        struct f71805f_data *data = platform_get_drvdata(pdev);
+        platform_set_drvdata(pdev, NULL);
+        hwmon_device_unregister(data->class_dev);
+        kfree(data);
+        return 0;
+}
+static struct platform_driver f71805f_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = DRVNAME,
+        },
+        .probe          = f71805f_probe,
+        .remove         = __devexit_p(f71805f_remove),
+};
+static int __init f71805f_device_add(unsigned short address)
+{
+        int err;
+        pdev = platform_device_alloc(DRVNAME, address);
+        if (!pdev) {
+                err = -ENOMEM;
+                printk(KERN_ERR DRVNAME ": Device allocation failed\n");
+                goto exit;
+        }
+        f71805f_resource.start = address;
+        f71805f_resource.end = address + REGION_LENGTH - 1;
+        f71805f_resource.name = pdev->name;
+        err = platform_device_add_resources(pdev, &f71805f_resource, 1);
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Device resource addition failed "
+                       "(%d)\n", err);
+                goto exit_device_put;
+        }
+        err = platform_device_add(pdev);
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
+                       err);
+                goto exit_device_put;
+        }
+        return 0;
+exit_device_put:
+        platform_device_put(pdev);
+exit:
+        return err;
+}
+static int __init f71805f_find(int sioaddr, unsigned short *address)
+{
+        int err = -ENODEV;
+        u16 devid;
+        superio_enter(sioaddr);
+        devid = superio_inw(sioaddr, SIO_REG_MANID);
+        if (devid != SIO_FINTEK_ID)
+                goto exit;
+        devid = superio_inw(sioaddr, SIO_REG_DEVID);
+        if (devid != SIO_F71805F_ID) {
+                printk(KERN_INFO DRVNAME ": Unsupported Fintek device, "
+                       "skipping\n");
+                goto exit;
+        }
+        superio_select(sioaddr, F71805F_LD_HWM);
+        if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) {
+                printk(KERN_WARNING DRVNAME ": Device not activated, "
+                       "skipping\n");
+                goto exit;
+        }
+        *address = superio_inw(sioaddr, SIO_REG_ADDR);
+        if (*address == 0) {
+                printk(KERN_WARNING DRVNAME ": Base address not set, "
+                       "skipping\n");
+                goto exit;
+        }
+        err = 0;
+        printk(KERN_INFO DRVNAME ": Found F71805F chip at %#x, revision %u\n",
+               *address, superio_inb(sioaddr, SIO_REG_DEVREV));
+exit:
+        superio_exit(sioaddr);
+        return err;
+}
+static int __init f71805f_init(void)
+{
+        int err;
+        unsigned short address;
+        if (f71805f_find(0x2e, &address)
+         && f71805f_find(0x4e, &address))
+                return -ENODEV;
+        err = platform_driver_register(&f71805f_driver);
+        if (err)
+                goto exit;
+        /* Sets global pdev as a side effect */
+        err = f71805f_device_add(address);
+        if (err)
+                goto exit_driver;
+        return 0;
+exit_driver:
+        platform_driver_unregister(&f71805f_driver);
+exit:
+        return err;
+}
+static void __exit f71805f_exit(void)
+{
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&f71805f_driver);
+}
+MODULE_AUTHOR("Jean Delvare <khali@linux-fr>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("F71805F hardware monitoring driver");
+module_init(f71805f_init);
+module_exit(f71805f_exit);
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index 0da7c9c508c3..e87d52c59940 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -45,8 +45,7 @@
 /* Addresses to scan */
-static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
+static unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
-                                        0x2e, 0x2f, I2C_CLIENT_END };
 static unsigned short isa_address;
 /* Insmod parameters */
@@ -830,6 +829,11 @@ static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
        if ((err = i2c_attach_client(new_client)))
                goto ERROR2;
+        if (!is_isa)
+                dev_info(&new_client->dev, "The I2C interface to IT87xxF "
+                         "hardware monitoring chips is deprecated. Please "
+                         "report if you still rely on it.\n");
        /* Check PWM configuration */
        enable_pwm_interface = it87_check_pwm(new_client);
diff --git a/drivers/hwmon/lm77.c b/drivers/hwmon/lm77.c
index a2f420d01fb7..df9e02aaa70a 100644
--- a/drivers/hwmon/lm77.c
+++ b/drivers/hwmon/lm77.c
@@ -87,15 +87,15 @@ static struct i2c_driver lm77_driver = {
 /* In the temperature registers, the low 3 bits are not part of the
   temperature values; they are the status bits. */
-static inline u16 LM77_TEMP_TO_REG(int temp)
+static inline s16 LM77_TEMP_TO_REG(int temp)
 {
        int ntemp = SENSORS_LIMIT(temp, LM77_TEMP_MIN, LM77_TEMP_MAX);
-        return (u16)((ntemp / 500) * 8);
+        return (ntemp / 500) * 8;
 }
-static inline int LM77_TEMP_FROM_REG(u16 reg)
+static inline int LM77_TEMP_FROM_REG(s16 reg)
 {
-        return ((int)reg / 8) * 500;
+        return (reg / 8) * 500;
 }
 /* sysfs stuff */
diff --git a/drivers/hwmon/w83792d.c b/drivers/hwmon/w83792d.c
index b176bf0c4c7b..a2f6bb676235 100644
--- a/drivers/hwmon/w83792d.c
+++ b/drivers/hwmon/w83792d.c
@@ -303,10 +303,6 @@ struct w83792d_data {
 static int w83792d_attach_adapter(struct i2c_adapter *adapter);
 static int w83792d_detect(struct i2c_adapter *adapter, int address, int kind);
 static int w83792d_detach_client(struct i2c_client *client);
-static int w83792d_read_value(struct i2c_client *client, u8 register);
-static int w83792d_write_value(struct i2c_client *client, u8 register,
-                                u8 value);
 static struct w83792d_data *w83792d_update_device(struct device *dev);
 #ifdef DEBUG
@@ -329,6 +325,20 @@ static inline long in_count_from_reg(int nr, struct w83792d_data *data)
        return ((data->in[nr] << 2) | ((data->low_bits >> (2 * nr)) & 0x03));
 }
+/* The SMBus locks itself. The Winbond W83792D chip has a bank register,
+   but the driver only accesses registers in bank 0, so we don't have
+   to switch banks and lock access between switches. */
+static inline int w83792d_read_value(struct i2c_client *client, u8 reg)
+{
+        return i2c_smbus_read_byte_data(client, reg);
+}
+static inline int
+w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+        return i2c_smbus_write_byte_data(client, reg, value);
+}
 /* following are the sysfs callback functions */
 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
                        char *buf)
@@ -1386,19 +1396,6 @@ w83792d_detach_client(struct i2c_client *client)
        return 0;
 }
-/* The SMBus locks itself. The Winbond W83792D chip has a bank register,
-   but the driver only accesses registers in bank 0, so we don't have
-   to switch banks and lock access between switches. */
-static int w83792d_read_value(struct i2c_client *client, u8 reg)
-{
-        return i2c_smbus_read_byte_data(client, reg);
-}
-static int w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
-{
-        return i2c_smbus_write_byte_data(client, reg, value);
-}
 static void
 w83792d_init_client(struct i2c_client *client)
 {
diff --git a/drivers/i2c/algos/i2c-algo-sibyte.c b/drivers/i2c/algos/i2c-algo-sibyte.c
index 938848ae162d..3df3f09995c2 100644
--- a/drivers/i2c/algos/i2c-algo-sibyte.c
+++ b/drivers/i2c/algos/i2c-algo-sibyte.c
@@ -202,7 +202,7 @@ EXPORT_SYMBOL(i2c_sibyte_del_bus);
 #ifdef MODULE
 MODULE_AUTHOR("Kip Walker, Broadcom Corp.");
 MODULE_DESCRIPTION("SiByte I2C-Bus algorithm");
-MODULE_PARM(bit_scan, "i");
+module_param(bit_scan, int, 0);
 MODULE_PARM_DESC(bit_scan, "Scan for active chips on the bus");
 MODULE_LICENSE("GPL");
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 08d5b8fed2dc..ff92735c7c85 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -124,6 +124,7 @@ config I2C_I801
            ICH6
            ICH7
            ESB2
+            ICH8
          This driver can also be built as a module.  If so, the module
          will be called i2c-i801.
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index 1c752ddc10e2..8e0f3158215f 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -32,6 +32,7 @@
    ICH6                266A
    ICH7                27DA
    ESB2                269B
+    ICH8                283E
    This driver supports several versions of Intel's I/O Controller Hubs (ICH).
    For SMBus support, they are similar to the PIIX4 and are part
    of Intel's '810' and other chipsets.
@@ -527,6 +528,7 @@ static struct pci_device_id i801_ids[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_16) },
        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_17) },
        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_17) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_5) },
        { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-parport-light.c b/drivers/i2c/busses/i2c-parport-light.c
index 3e5eba9fcacb..c63025a4c861 100644
--- a/drivers/i2c/busses/i2c-parport-light.c
+++ b/drivers/i2c/busses/i2c-parport-light.c
@@ -121,14 +121,11 @@ static struct i2c_adapter parport_adapter = {
 static int __init i2c_parport_init(void)
 {
-        int type_count;
+        if (type < 0 || type >= ARRAY_SIZE(adapter_parm)) {
-        type_count = sizeof(adapter_parm)/sizeof(struct adapter_parm);
-        if (type < 0 || type >= type_count) {
                printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
                type = 0;
        }
-        
        if (base == 0) {
                printk(KERN_INFO "i2c-parport: using default base 0x%x\n", DEFAULT_BASE);
                base = DEFAULT_BASE;
@@ -152,7 +149,7 @@ static int __init i2c_parport_init(void)
                release_region(base, 3);
                return -ENODEV;
        }
-        
        return 0;
 }
diff --git a/drivers/i2c/busses/i2c-parport.c b/drivers/i2c/busses/i2c-parport.c
index 2854d858fc9b..7e2e8cd1c14a 100644
--- a/drivers/i2c/busses/i2c-parport.c
+++ b/drivers/i2c/busses/i2c-parport.c
@@ -241,14 +241,11 @@ static struct parport_driver i2c_parport_driver = {
 static int __init i2c_parport_init(void)
 {
-        int type_count;
+        if (type < 0 || type >= ARRAY_SIZE(adapter_parm)) {
-        type_count = sizeof(adapter_parm)/sizeof(struct adapter_parm);
-        if (type < 0 || type >= type_count) {
                printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
                type = 0;
        }
-        
        return parport_register_driver(&i2c_parport_driver);
 }
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index 86e2234faf80..7579f4b256a8 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -861,7 +861,7 @@ static irqreturn_t i2c_pxa_handler(int this_irq, void *dev_id, struct pt_regs *r
                decode_ISR(isr);
        }
-        if (i2c->irqlogidx < sizeof(i2c->isrlog)/sizeof(u32))
+        if (i2c->irqlogidx < ARRAY_SIZE(i2c->isrlog))
                i2c->isrlog[i2c->irqlogidx++] = isr;
        show_state(i2c);
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 0ce58b506046..1a2c9ab5d9e3 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -946,6 +946,20 @@ s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *val
        }
 }
+s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
+                                   u8 length, u8 *values)
+{
+        union i2c_smbus_data data;
+        if (length > I2C_SMBUS_BLOCK_MAX)
+                length = I2C_SMBUS_BLOCK_MAX;
+        data.block[0] = length;
+        memcpy(data.block + 1, values, length);
+        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
+                              I2C_SMBUS_WRITE, command,
+                              I2C_SMBUS_I2C_BLOCK_DATA, &data);
+}
 /* Simulate a SMBus command using the i2c protocol 
   No checking of parameters is done!  */
 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr, 
@@ -1150,6 +1164,7 @@ EXPORT_SYMBOL(i2c_smbus_read_word_data);
 EXPORT_SYMBOL(i2c_smbus_write_word_data);
 EXPORT_SYMBOL(i2c_smbus_write_block_data);
 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
+EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
 MODULE_DESCRIPTION("I2C-Bus main module");
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 6c60a9d2afd8..09086b8b6486 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -190,7 +190,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
                if (lba48) {
                        task_ioreg_t tasklets[10];
-                        pr_debug("%s: LBA=0x%012llx\n", drive->name, block);
+                        pr_debug("%s: LBA=0x%012llx\n", drive->name,
+                                        (unsigned long long)block);
                        tasklets[0] = 0;
                        tasklets[1] = 0;
@@ -317,7 +318,8 @@ static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, s
        pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
                 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
-                 block, rq->nr_sectors, (unsigned long)rq->buffer);
+                 (unsigned long long)block, rq->nr_sectors,
+                 (unsigned long)rq->buffer);
        if (hwif->rw_disk)
                hwif->rw_disk(drive, rq);
diff --git a/drivers/media/dvb/b2c2/Kconfig b/drivers/media/dvb/b2c2/Kconfig
index 2583a865a58e..2963605c0ecc 100644
--- a/drivers/media/dvb/b2c2/Kconfig
+++ b/drivers/media/dvb/b2c2/Kconfig
@@ -4,7 +4,7 @@ config DVB_B2C2_FLEXCOP
        select DVB_STV0299
        select DVB_MT352
        select DVB_MT312
-        select DVB_NXT2002
+        select DVB_NXT200X
        select DVB_STV0297
        select DVB_BCM3510
        select DVB_LGDT330X
diff --git a/drivers/media/dvb/b2c2/flexcop-common.h b/drivers/media/dvb/b2c2/flexcop-common.h
index 344a3c898460..7d7e1613c5a7 100644
--- a/drivers/media/dvb/b2c2/flexcop-common.h
+++ b/drivers/media/dvb/b2c2/flexcop-common.h
@@ -116,11 +116,9 @@ void flexcop_dma_free(struct flexcop_dma *dma);
 int flexcop_dma_control_timer_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff);
 int flexcop_dma_control_size_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff);
-int flexcop_dma_control_packet_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff);
 int flexcop_dma_config(struct flexcop_device *fc, struct flexcop_dma *dma, flexcop_dma_index_t dma_idx);
 int flexcop_dma_xfer_control(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, flexcop_dma_addr_index_t index, int onoff);
 int flexcop_dma_config_timer(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, u8 cycles);
-int flexcop_dma_config_packet_count(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, u8 packets);
 /* from flexcop-eeprom.c */
 /* the PCI part uses this call to get the MAC address, the USB part has its own */
diff --git a/drivers/media/dvb/b2c2/flexcop-dma.c b/drivers/media/dvb/b2c2/flexcop-dma.c
index cf4ed1df6086..6f592bc32d22 100644
--- a/drivers/media/dvb/b2c2/flexcop-dma.c
+++ b/drivers/media/dvb/b2c2/flexcop-dma.c
@@ -169,38 +169,3 @@ int flexcop_dma_config_timer(struct flexcop_device *fc,
 }
 EXPORT_SYMBOL(flexcop_dma_config_timer);
-/* packet IRQ does not exist in FCII or FCIIb - according to data book and tests */
-int flexcop_dma_control_packet_irq(struct flexcop_device *fc,
-                flexcop_dma_index_t no,
-                int onoff)
-{
-        flexcop_ibi_value v = fc->read_ibi_reg(fc,ctrl_208);
-        deb_rdump("reg: %03x: %x\n",ctrl_208,v.raw);
-        if (no & FC_DMA_1)
-                v.ctrl_208.DMA1_Size_IRQ_Enable_sig = onoff;
-        if (no & FC_DMA_2)
-                v.ctrl_208.DMA2_Size_IRQ_Enable_sig = onoff;
-        fc->write_ibi_reg(fc,ctrl_208,v);
-        deb_rdump("reg: %03x: %x\n",ctrl_208,v.raw);
-        return 0;
-}
-EXPORT_SYMBOL(flexcop_dma_control_packet_irq);
-int flexcop_dma_config_packet_count(struct flexcop_device *fc,
-                flexcop_dma_index_t dma_idx,
-                u8 packets)
-{
-        flexcop_ibi_register r = (dma_idx & FC_DMA_1) ? dma1_004 : dma2_014;
-        flexcop_ibi_value v = fc->read_ibi_reg(fc,r);
-        flexcop_dma_remap(fc,dma_idx,1);
-        v.dma_0x4_remap.DMA_maxpackets = packets;
-        fc->write_ibi_reg(fc,r,v);
-        return 0;
-}
-EXPORT_SYMBOL(flexcop_dma_config_packet_count);
diff --git a/drivers/media/dvb/b2c2/flexcop-fe-tuner.c b/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
index 0b940e152b79..390cc3a99ce6 100644
--- a/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
+++ b/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
@@ -9,7 +9,7 @@
 #include "stv0299.h"
 #include "mt352.h"
-#include "nxt2002.h"
+#include "nxt200x.h"
 #include "bcm3510.h"
 #include "stv0297.h"
 #include "mt312.h"
@@ -343,9 +343,10 @@ static struct lgdt330x_config air2pc_atsc_hd5000_config = {
        .clock_polarity_flip = 1,
 };
-static struct nxt2002_config samsung_tbmv_config = {
+static struct nxt200x_config samsung_tbmv_config = {
        .demod_address    = 0x0a,
-        .request_firmware = flexcop_fe_request_firmware,
+        .pll_address      = 0xc2,
+        .pll_desc         = &dvb_pll_samsung_tbmv,
 };
 static struct bcm3510_config air2pc_atsc_first_gen_config = {
@@ -505,7 +506,7 @@ int flexcop_frontend_init(struct flexcop_device *fc)
                info("found the mt352 at i2c address: 0x%02x",samsung_tdtc9251dh0_config.demod_address);
        } else
        /* try the air atsc 2nd generation (nxt2002) */
-        if ((fc->fe = nxt2002_attach(&samsung_tbmv_config, &fc->i2c_adap)) != NULL) {
+        if ((fc->fe = nxt200x_attach(&samsung_tbmv_config, &fc->i2c_adap)) != NULL) {
                fc->dev_type          = FC_AIR_ATSC2;
                info("found the nxt2002 at i2c address: 0x%02x",samsung_tbmv_config.demod_address);
        } else
diff --git a/drivers/media/dvb/b2c2/flexcop-misc.c b/drivers/media/dvb/b2c2/flexcop-misc.c
index 62282d8dbfa8..167583bf0621 100644
--- a/drivers/media/dvb/b2c2/flexcop-misc.c
+++ b/drivers/media/dvb/b2c2/flexcop-misc.c
@@ -36,14 +36,14 @@ void flexcop_determine_revision(struct flexcop_device *fc)
        /* bus parts have to decide if hw pid filtering is used or not. */
 }
-const char *flexcop_revision_names[] = {
+static const char *flexcop_revision_names[] = {
        "Unkown chip",
        "FlexCopII",
        "FlexCopIIb",
        "FlexCopIII",
 };
-const char *flexcop_device_names[] = {
+static const char *flexcop_device_names[] = {
        "Unkown device",
        "Air2PC/AirStar 2 DVB-T",
        "Air2PC/AirStar 2 ATSC 1st generation",
@@ -54,7 +54,7 @@ const char *flexcop_device_names[] = {
        "Air2PC/AirStar 2 ATSC 3rd generation (HD5000)",
 };
-const char *flexcop_bus_names[] = {
+static const char *flexcop_bus_names[] = {
        "USB",
        "PCI",
 };
diff --git a/drivers/media/dvb/b2c2/flexcop-pci.c b/drivers/media/dvb/b2c2/flexcop-pci.c
index 2f76eb3fea40..9bc40bdcc282 100644
--- a/drivers/media/dvb/b2c2/flexcop-pci.c
+++ b/drivers/media/dvb/b2c2/flexcop-pci.c
@@ -161,8 +161,10 @@ static irqreturn_t flexcop_pci_isr(int irq, void *dev_id, struct pt_regs *regs)
                        fc->read_ibi_reg(fc,dma1_008).dma_0x8.dma_cur_addr << 2;
                u32 cur_pos = cur_addr - fc_pci->dma[0].dma_addr0;
-                deb_irq("%u irq: %08x cur_addr: %08x: cur_pos: %08x, last_cur_pos: %08x ",
+                deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, last_cur_pos: %08x ",
-                                jiffies_to_usecs(jiffies - fc_pci->last_irq),v.raw,cur_addr,cur_pos,fc_pci->last_dma1_cur_pos);
+                                jiffies_to_usecs(jiffies - fc_pci->last_irq),
+                                v.raw, (unsigned long long)cur_addr, cur_pos,
+                                fc_pci->last_dma1_cur_pos);
                fc_pci->last_irq = jiffies;
                /* buffer end was reached, restarted from the beginning
diff --git a/drivers/media/dvb/b2c2/flexcop-reg.h b/drivers/media/dvb/b2c2/flexcop-reg.h
index 3153f9513c63..491f9bd6e195 100644
--- a/drivers/media/dvb/b2c2/flexcop-reg.h
+++ b/drivers/media/dvb/b2c2/flexcop-reg.h
@@ -16,8 +16,6 @@ typedef enum {
        FLEXCOP_III,
 } flexcop_revision_t;
-extern const char *flexcop_revision_names[];
 typedef enum {
        FC_UNK = 0,
        FC_AIR_DVB,
@@ -34,8 +32,6 @@ typedef enum {
        FC_PCI,
 } flexcop_bus_t;
-extern const char *flexcop_device_names[];
 /* FlexCop IBI Registers */
 #if defined(__LITTLE_ENDIAN)
        #include "flexcop_ibi_value_le.h"
diff --git a/drivers/media/dvb/bt8xx/bt878.c b/drivers/media/dvb/bt8xx/bt878.c
index a04bb61f21f4..34c3189a1a33 100644
--- a/drivers/media/dvb/bt8xx/bt878.c
+++ b/drivers/media/dvb/bt8xx/bt878.c
@@ -381,6 +381,23 @@ bt878_device_control(struct bt878 *bt, unsigned int cmd, union dst_gpio_packet *
 EXPORT_SYMBOL(bt878_device_control);
+struct cards card_list[] __devinitdata = {
+        { 0x01010071, BTTV_BOARD_NEBULA_DIGITV,                 "Nebula Electronics DigiTV" },
+        { 0x07611461, BTTV_BOARD_AVDVBT_761,                    "AverMedia AverTV DVB-T 761" },
+        { 0x001c11bd, BTTV_BOARD_PINNACLESAT,                   "Pinnacle PCTV Sat" },
+        { 0x002611bd, BTTV_BOARD_TWINHAN_DST,                   "Pinnacle PCTV SAT CI" },
+        { 0x00011822, BTTV_BOARD_TWINHAN_DST,                   "Twinhan VisionPlus DVB" },
+        { 0xfc00270f, BTTV_BOARD_TWINHAN_DST,                   "ChainTech digitop DST-1000 DVB-S" },
+        { 0x07711461, BTTV_BOARD_AVDVBT_771,                    "AVermedia AverTV DVB-T 771" },
+        { 0xdb1018ac, BTTV_BOARD_DVICO_DVBT_LITE,               "DViCO FusionHDTV DVB-T Lite" },
+        { 0xd50018ac, BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE,       "DViCO FusionHDTV 5 Lite" },
+        { 0x20007063, BTTV_BOARD_PC_HDTV,                       "pcHDTV HD-2000 TV"},
+        { 0, -1, NULL }
+};
 /***********************/
 /* PCI device handling */
 /***********************/
@@ -388,18 +405,41 @@ EXPORT_SYMBOL(bt878_device_control);
 static int __devinit bt878_probe(struct pci_dev *dev,
                                 const struct pci_device_id *pci_id)
 {
-        int result;
+        int result = 0, has_dvb = 0, i;
        unsigned char lat;
        struct bt878 *bt;
 #if defined(__powerpc__)
        unsigned int cmd;
 #endif
+        unsigned int cardid;
+        unsigned short id;
+        struct cards *dvb_cards;
        printk(KERN_INFO "bt878: Bt878 AUDIO function found (%d).\n",
               bt878_num);
        if (pci_enable_device(dev))
                return -EIO;
+        pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &id);
+        cardid = id << 16;
+        pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &id);
+        cardid |= id;
+        for (i = 0, dvb_cards = card_list; i < ARRAY_SIZE(card_list); i++, dvb_cards++) {
+                if (cardid == dvb_cards->pci_id) {
+                        printk("%s: card id=[0x%x],[ %s ] has DVB functions.\n",
+                                __func__, cardid, dvb_cards->name);
+                        has_dvb = 1;
+                }
+        }
+        if (!has_dvb) {
+                printk("%s: card id=[0x%x], Unknown card.\nExiting..\n", __func__, cardid);
+                result = -EINVAL;
+                goto fail0;
+        }
        bt = &bt878[bt878_num];
        bt->dev = dev;
        bt->nr = bt878_num;
@@ -416,6 +456,8 @@ static int __devinit bt878_probe(struct pci_dev *dev,
        pci_read_config_byte(dev, PCI_CLASS_REVISION, &bt->revision);
        pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
        printk(KERN_INFO "bt878(%d): Bt%x (rev %d) at %02x:%02x.%x, ",
               bt878_num, bt->id, bt->revision, dev->bus->number,
               PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
diff --git a/drivers/media/dvb/bt8xx/bt878.h b/drivers/media/dvb/bt8xx/bt878.h
index a73baf00ca39..9faf93770d08 100644
--- a/drivers/media/dvb/bt8xx/bt878.h
+++ b/drivers/media/dvb/bt8xx/bt878.h
@@ -88,6 +88,23 @@
 #define BT878_RISC_SYNC_MASK    (1 << 15)
+#define BTTV_BOARD_UNKNOWN                 0x00
+#define BTTV_BOARD_PINNACLESAT             0x5e
+#define BTTV_BOARD_NEBULA_DIGITV           0x68
+#define BTTV_BOARD_PC_HDTV                 0x70
+#define BTTV_BOARD_TWINHAN_DST             0x71
+#define BTTV_BOARD_AVDVBT_771              0x7b
+#define BTTV_BOARD_AVDVBT_761              0x7c
+#define BTTV_BOARD_DVICO_DVBT_LITE         0x80
+#define BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE 0x87
+struct cards {
+        __u32 pci_id;
+        __u16 card_id;
+        char  *name;
+};
 extern int bt878_num;
 struct bt878 {
diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig
index 90a69d343b79..d3df12039b06 100644
--- a/drivers/media/dvb/dvb-usb/Kconfig
+++ b/drivers/media/dvb/dvb-usb/Kconfig
@@ -83,12 +83,18 @@ config DVB_USB_UMT_010
          Say Y here to support the HanfTek UMT-010 USB2.0 stick-sized DVB-T receiver.
 config DVB_USB_CXUSB
-        tristate "Medion MD95700 hybrid USB2.0 (Conexant) support"
+        tristate "Conexant USB2.0 hybrid reference design support"
        depends on DVB_USB
        select DVB_CX22702
+        select DVB_LGDT330X
+        select DVB_MT352
        help
-          Say Y here to support the Medion MD95700 hybrid USB2.0 device. Currently
+          Say Y here to support the Conexant USB2.0 hybrid reference design.
-          only the DVB-T part is supported.
+          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_DIGITV
        tristate "Nebula Electronics uDigiTV DVB-T USB2.0 support"
diff --git a/drivers/media/dvb/dvb-usb/cxusb.c b/drivers/media/dvb/dvb-usb/cxusb.c
index a7fb06f4cd34..f327fac1688e 100644
--- a/drivers/media/dvb/dvb-usb/cxusb.c
+++ b/drivers/media/dvb/dvb-usb/cxusb.c
@@ -184,7 +184,7 @@ static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
        return 0;
 }
-struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
+static struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
        { 0xfe, 0x02, KEY_TV },
        { 0xfe, 0x0e, KEY_MP3 },
        { 0xfe, 0x1a, KEY_DVD },
@@ -234,7 +234,7 @@ struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
 {
-        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x38 };
+        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 };
@@ -255,7 +255,7 @@ static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
 static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
 {       /* used in both lgz201 and th7579 */
-        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x39 };
+        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 };
@@ -273,7 +273,7 @@ static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
        return 0;
 }
-struct cx22702_config cxusb_cx22702_config = {
+static struct cx22702_config cxusb_cx22702_config = {
        .demod_address = 0x63,
        .output_mode = CX22702_PARALLEL_OUTPUT,
@@ -282,13 +282,13 @@ struct cx22702_config cxusb_cx22702_config = {
        .pll_set  = dvb_usb_pll_set_i2c,
 };
-struct lgdt330x_config cxusb_lgdt330x_config = {
+static struct lgdt330x_config cxusb_lgdt330x_config = {
        .demod_address = 0x0e,
        .demod_chip    = LGDT3303,
        .pll_set       = dvb_usb_pll_set_i2c,
 };
-struct mt352_config cxusb_dee1601_config = {
+static struct mt352_config cxusb_dee1601_config = {
        .demod_address = 0x0f,
        .demod_init    = cxusb_dee1601_demod_init,
        .pll_set       = dvb_usb_pll_set,
diff --git a/drivers/media/dvb/dvb-usb/digitv.c b/drivers/media/dvb/dvb-usb/digitv.c
index e6c55c9c9417..caa1346e3063 100644
--- a/drivers/media/dvb/dvb-usb/digitv.c
+++ b/drivers/media/dvb/dvb-usb/digitv.c
@@ -175,11 +175,13 @@ static int digitv_probe(struct usb_interface *intf,
        if ((ret = dvb_usb_device_init(intf,&digitv_properties,THIS_MODULE,&d)) == 0) {
                u8 b[4] = { 0 };
-                b[0] = 1;
+                if (d != NULL) { /* do that only when the firmware is loaded */
-                digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0);
+                        b[0] = 1;
+                        digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0);
-                b[0] = 0;
+                        b[0] = 0;
-                digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0);
+                        digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0);
+                }
        }
        return ret;
 }
@@ -194,7 +196,7 @@ static struct dvb_usb_properties digitv_properties = {
        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
        .usb_ctrl = CYPRESS_FX2,
-        .firmware = "dvb-usb-digitv-01.fw",
+        .firmware = "dvb-usb-digitv-02.fw",
        .size_of_priv     = 0,
@@ -229,6 +231,7 @@ static struct dvb_usb_properties digitv_properties = {
                        { &digitv_table[0], NULL },
                        { NULL },
                },
+                { NULL },
        }
 };
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
index 8535895819fb..9222b0a81f74 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
@@ -24,6 +24,9 @@ static struct usb_cypress_controller cypress[] = {
        { .id = CYPRESS_FX2,     .name = "Cypress FX2",     .cpu_cs_register = 0xe600 },
 };
+static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx,
+                               int *pos);
 /*
 * load a firmware packet to the device
 */
@@ -112,7 +115,8 @@ int dvb_usb_download_firmware(struct usb_device *udev, struct dvb_usb_properties
        return ret;
 }
-int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos)
+static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx,
+                               int *pos)
 {
        u8 *b = (u8 *) &fw->data[*pos];
        int data_offs = 4;
@@ -142,5 +146,3 @@ int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos)
        return *pos;
 }
-EXPORT_SYMBOL(dvb_usb_get_hexline);
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb.h b/drivers/media/dvb/dvb-usb/dvb-usb.h
index dd568396e594..5e5d21ad93c9 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb.h
+++ b/drivers/media/dvb/dvb-usb/dvb-usb.h
@@ -341,7 +341,6 @@ struct hexline {
        u8 data[255];
        u8 chk;
 };
-extern int dvb_usb_get_hexline(const struct firmware *, struct hexline *, int *);
 extern int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type);
 #endif
diff --git a/drivers/media/dvb/dvb-usb/vp702x.c b/drivers/media/dvb/dvb-usb/vp702x.c
index afa00fdb5ec0..4a95eca81c5c 100644
--- a/drivers/media/dvb/dvb-usb/vp702x.c
+++ b/drivers/media/dvb/dvb-usb/vp702x.c
@@ -53,7 +53,8 @@ int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8
        return ret;
 }
-int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
+static int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
+                             u16 index, u8 *b, int blen)
 {
        deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
        debug_dump(b,blen,deb_xfer);
@@ -88,7 +89,8 @@ unlock:
        return ret;
 }
-int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, int olen, u8 *i, int ilen, int msec)
+static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o,
+                                int olen, u8 *i, int ilen, int msec)
 {
        u8 bout[olen+2];
        u8 bin[ilen+1];
diff --git a/drivers/media/dvb/dvb-usb/vp702x.h b/drivers/media/dvb/dvb-usb/vp702x.h
index a808d48e7bf2..c2f97f96c21f 100644
--- a/drivers/media/dvb/dvb-usb/vp702x.h
+++ b/drivers/media/dvb/dvb-usb/vp702x.h
@@ -101,8 +101,6 @@ extern int dvb_usb_vp702x_debug;
 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_inout_cmd(struct dvb_usb_device *d, u8 cmd, 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);
-extern int vp702x_usb_out_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
index 5242cca5db4a..9999336aeeb6 100644
--- a/drivers/media/dvb/dvb-usb/vp7045-fe.c
+++ b/drivers/media/dvb/dvb-usb/vp7045-fe.c
@@ -23,10 +23,11 @@
 struct vp7045_fe_state {
        struct dvb_frontend fe;
+        struct dvb_frontend_ops ops;
        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;
@@ -150,7 +151,8 @@ struct dvb_frontend * vp7045_fe_attach(struct dvb_usb_device *d)
                goto error;
        s->d = d;
-        s->fe.ops = &vp7045_fe_ops;
+        memcpy(&s->ops, &vp7045_fe_ops, sizeof(struct dvb_frontend_ops));
+        s->fe.ops = &s->ops;
        s->fe.demodulator_priv = s;
        goto success;
diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig
index db3a8b40031e..76b6a2aef32f 100644
--- a/drivers/media/dvb/frontends/Kconfig
+++ b/drivers/media/dvb/frontends/Kconfig
@@ -28,12 +28,6 @@ config DVB_TDA8083
        help
          A DVB-S tuner module. Say Y when you want to support this frontend.
-config DVB_TDA80XX
-        tristate "Philips TDA8044 or TDA8083 based"
-        depends on DVB_CORE
-        help
-          A DVB-S tuner module. Say Y when you want to support this frontend.
 config DVB_MT312
        tristate "Zarlink MT312 based"
        depends on DVB_CORE
@@ -139,12 +133,6 @@ config DVB_DIB3000MC
 comment "DVB-C (cable) frontends"
        depends on DVB_CORE
-config DVB_ATMEL_AT76C651
-        tristate "Atmel AT76C651 based"
-        depends on DVB_CORE
-        help
-          A DVB-C tuner module. Say Y when you want to support this frontend.
 config DVB_VES1820
        tristate "VLSI VES1820 based"
        depends on DVB_CORE
@@ -166,18 +154,6 @@ config DVB_STV0297
 comment "ATSC (North American/Korean Terresterial DTV) frontends"
        depends on DVB_CORE
-config DVB_NXT2002
-        tristate "Nxt2002 based"
-        depends on DVB_CORE
-        select FW_LOADER
-        help
-          An ATSC 8VSB tuner module. Say Y when you want to support this frontend.
-          This driver needs external firmware. Please use the command
-          "<kerneldir>/Documentation/dvb/get_dvb_firmware nxt2002" to
-          download/extract it, and then copy it to /usr/lib/hotplug/firmware
-          or /lib/firmware (depending on configuration of firmware hotplug).
 config DVB_NXT200X
        tristate "Nextwave NXT2002/NXT2004 based"
        depends on DVB_CORE
diff --git a/drivers/media/dvb/frontends/Makefile b/drivers/media/dvb/frontends/Makefile
index 615ec830e1c9..1af769cd90c0 100644
--- a/drivers/media/dvb/frontends/Makefile
+++ b/drivers/media/dvb/frontends/Makefile
@@ -8,7 +8,6 @@ obj-$(CONFIG_DVB_CORE) += dvb-pll.o
 obj-$(CONFIG_DVB_STV0299) += stv0299.o
 obj-$(CONFIG_DVB_SP8870) += sp8870.o
 obj-$(CONFIG_DVB_CX22700) += cx22700.o
-obj-$(CONFIG_DVB_ATMEL_AT76C651) += at76c651.o
 obj-$(CONFIG_DVB_CX24110) += cx24110.o
 obj-$(CONFIG_DVB_TDA8083) += tda8083.o
 obj-$(CONFIG_DVB_L64781) += l64781.o
@@ -22,10 +21,8 @@ obj-$(CONFIG_DVB_SP887X) += sp887x.o
 obj-$(CONFIG_DVB_NXT6000) += nxt6000.o
 obj-$(CONFIG_DVB_MT352) += mt352.o
 obj-$(CONFIG_DVB_CX22702) += cx22702.o
-obj-$(CONFIG_DVB_TDA80XX) += tda80xx.o
 obj-$(CONFIG_DVB_TDA10021) += tda10021.o
 obj-$(CONFIG_DVB_STV0297) += stv0297.o
-obj-$(CONFIG_DVB_NXT2002) += nxt2002.o
 obj-$(CONFIG_DVB_NXT200X) += nxt200x.o
 obj-$(CONFIG_DVB_OR51211) += or51211.o
 obj-$(CONFIG_DVB_OR51132) += or51132.o
diff --git a/drivers/media/dvb/frontends/at76c651.c b/drivers/media/dvb/frontends/at76c651.c
deleted file mode 100644
index 8e0f4b3a1417..000000000000
--- a/drivers/media/dvb/frontends/at76c651.c
+++ /dev/null
@@ -1,450 +0,0 @@
-/*
- * at76c651.c
- *
- * Atmel DVB-C Frontend Driver (at76c651/tua6010xs)
- *
- * Copyright (C) 2001 fnbrd <fnbrd@gmx.de>
- *             & 2002-2004 Andreas Oberritter <obi@linuxtv.org>
- *             & 2003 Wolfram Joost <dbox2@frokaschwei.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * AT76C651
- * http://www.nalanda.nitc.ac.in/industry/datasheets/atmel/acrobat/doc1293.pdf
- * http://www.atmel.com/atmel/acrobat/doc1320.pdf
- */
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/kernel.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/bitops.h>
-#include "dvb_frontend.h"
-#include "at76c651.h"
-struct at76c651_state {
-        struct i2c_adapter* i2c;
-        struct dvb_frontend_ops ops;
-        const struct at76c651_config* config;
-        struct dvb_frontend frontend;
-        /* revision of the chip */
-        u8 revision;
-        /* last QAM value set */
-        u8 qam;
-};
-static int debug;
-#define dprintk(args...) \
-        do { \
-                if (debug) printk(KERN_DEBUG "at76c651: " args); \
-        } while (0)
-#if ! defined(__powerpc__)
-static __inline__ int __ilog2(unsigned long x)
-{
-        int i;
-        if (x == 0)
-                return -1;
-        for (i = 0; x != 0; i++)
-                x >>= 1;
-        return i - 1;
-}
-#endif
-static int at76c651_writereg(struct at76c651_state* state, u8 reg, u8 data)
-{
-        int ret;
-        u8 buf[] = { reg, data };
-        struct i2c_msg msg =
-                { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
-        ret = i2c_transfer(state->i2c, &msg, 1);
-        if (ret != 1)
-                dprintk("%s: writereg error "
-                        "(reg == 0x%02x, val == 0x%02x, ret == %i)\n",
-                        __FUNCTION__, reg, data, ret);
-        msleep(10);
-        return (ret != 1) ? -EREMOTEIO : 0;
-}
-static u8 at76c651_readreg(struct at76c651_state* state, u8 reg)
-{
-        int ret;
-        u8 val;
-        struct i2c_msg msg[] = {
-                { .addr = state->config->demod_address, .flags = 0, .buf = &reg, .len = 1 },
-                { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = &val, .len = 1 }
-        };
-        ret = i2c_transfer(state->i2c, msg, 2);
-        if (ret != 2)
-                dprintk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
-        return val;
-}
-static int at76c651_reset(struct at76c651_state* state)
-{
-        return at76c651_writereg(state, 0x07, 0x01);
-}
-static void at76c651_disable_interrupts(struct at76c651_state* state)
-{
-        at76c651_writereg(state, 0x0b, 0x00);
-}
-static int at76c651_set_auto_config(struct at76c651_state *state)
-{
-        /*
-         * Autoconfig
-         */
-        at76c651_writereg(state, 0x06, 0x01);
-        /*
-         * Performance optimizations, should be done after autoconfig
-         */
-        at76c651_writereg(state, 0x10, 0x06);
-        at76c651_writereg(state, 0x11, ((state->qam == 5) || (state->qam == 7)) ? 0x12 : 0x10);
-        at76c651_writereg(state, 0x15, 0x28);
-        at76c651_writereg(state, 0x20, 0x09);
-        at76c651_writereg(state, 0x24, ((state->qam == 5) || (state->qam == 7)) ? 0xC0 : 0x90);
-        at76c651_writereg(state, 0x30, 0x90);
-        if (state->qam == 5)
-                at76c651_writereg(state, 0x35, 0x2A);
-        /*
-         * Initialize A/D-converter
-         */
-        if (state->revision == 0x11) {
-                at76c651_writereg(state, 0x2E, 0x38);
-                at76c651_writereg(state, 0x2F, 0x13);
-        }
-        at76c651_disable_interrupts(state);
-        /*
-         * Restart operation
-         */
-        at76c651_reset(state);
-        return 0;
-}
-static void at76c651_set_bbfreq(struct at76c651_state* state)
-{
-        at76c651_writereg(state, 0x04, 0x3f);
-        at76c651_writereg(state, 0x05, 0xee);
-}
-static int at76c651_set_symbol_rate(struct at76c651_state* state, u32 symbol_rate)
-{
-        u8 exponent;
-        u32 mantissa;
-        if (symbol_rate > 9360000)
-                return -EINVAL;
-        /*
-         * FREF = 57800 kHz
-         * exponent = 10 + floor (log2(symbol_rate / FREF))
-         * mantissa = (symbol_rate / FREF) * (1 << (30 - exponent))
-         */
-        exponent = __ilog2((symbol_rate << 4) / 903125);
-        mantissa = ((symbol_rate / 3125) * (1 << (24 - exponent))) / 289;
-        at76c651_writereg(state, 0x00, mantissa >> 13);
-        at76c651_writereg(state, 0x01, mantissa >> 5);
-        at76c651_writereg(state, 0x02, (mantissa << 3) | exponent);
-        return 0;
-}
-static int at76c651_set_qam(struct at76c651_state *state, fe_modulation_t qam)
-{
-        switch (qam) {
-        case QPSK:
-                state->qam = 0x02;
-                break;
-        case QAM_16:
-                state->qam = 0x04;
-                break;
-        case QAM_32:
-                state->qam = 0x05;
-                break;
-        case QAM_64:
-                state->qam = 0x06;
-                break;
-        case QAM_128:
-                state->qam = 0x07;
-                break;
-        case QAM_256:
-                state->qam = 0x08;
-                break;
-#if 0
-        case QAM_512:
-                state->qam = 0x09;
-                break;
-        case QAM_1024:
-                state->qam = 0x0A;
-                break;
-#endif
-        default:
-                return -EINVAL;
-        }
-        return at76c651_writereg(state, 0x03, state->qam);
-}
-static int at76c651_set_inversion(struct at76c651_state* state, fe_spectral_inversion_t inversion)
-{
-        u8 feciqinv = at76c651_readreg(state, 0x60);
-        switch (inversion) {
-        case INVERSION_OFF:
-                feciqinv |= 0x02;
-                feciqinv &= 0xFE;
-                break;
-        case INVERSION_ON:
-                feciqinv |= 0x03;
-                break;
-        case INVERSION_AUTO:
-                feciqinv &= 0xFC;
-                break;
-        default:
-                return -EINVAL;
-        }
-        return at76c651_writereg(state, 0x60, feciqinv);
-}
-static int at76c651_set_parameters(struct dvb_frontend* fe,
-                                   struct dvb_frontend_parameters *p)
-{
-        int ret;
-        struct at76c651_state* state = fe->demodulator_priv;
-        at76c651_writereg(state, 0x0c, 0xc3);
-        state->config->pll_set(fe, p);
-        at76c651_writereg(state, 0x0c, 0xc2);
-        if ((ret = at76c651_set_symbol_rate(state, p->u.qam.symbol_rate)))
-                return ret;
-        if ((ret = at76c651_set_inversion(state, p->inversion)))
-                return ret;
-        return at76c651_set_auto_config(state);
-}
-static int at76c651_set_defaults(struct dvb_frontend* fe)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        at76c651_set_symbol_rate(state, 6900000);
-        at76c651_set_qam(state, QAM_64);
-        at76c651_set_bbfreq(state);
-        at76c651_set_auto_config(state);
-        if (state->config->pll_init) {
-                at76c651_writereg(state, 0x0c, 0xc3);
-                state->config->pll_init(fe);
-                at76c651_writereg(state, 0x0c, 0xc2);
-        }
-        return 0;
-}
-static int at76c651_read_status(struct dvb_frontend* fe, fe_status_t* status)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        u8 sync;
-        /*
-         * Bits: FEC, CAR, EQU, TIM, AGC2, AGC1, ADC, PLL (PLL=0)
-         */
-        sync = at76c651_readreg(state, 0x80);
-        *status = 0;
-        if (sync & (0x04 | 0x10))       /* AGC1 || TIM */
-                *status |= FE_HAS_SIGNAL;
-        if (sync & 0x10)                /* TIM */
-                *status |= FE_HAS_CARRIER;
-        if (sync & 0x80)                /* FEC */
-                *status |= FE_HAS_VITERBI;
-        if (sync & 0x40)                /* CAR */
-                *status |= FE_HAS_SYNC;
-        if ((sync & 0xF0) == 0xF0)      /* TIM && EQU && CAR && FEC */
-                *status |= FE_HAS_LOCK;
-        return 0;
-}
-static int at76c651_read_ber(struct dvb_frontend* fe, u32* ber)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        *ber = (at76c651_readreg(state, 0x81) & 0x0F) << 16;
-        *ber |= at76c651_readreg(state, 0x82) << 8;
-        *ber |= at76c651_readreg(state, 0x83);
-        *ber *= 10;
-        return 0;
-}
-static int at76c651_read_signal_strength(struct dvb_frontend* fe, u16* strength)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        u8 gain = ~at76c651_readreg(state, 0x91);
-        *strength = (gain << 8) | gain;
-        return 0;
-}
-static int at76c651_read_snr(struct dvb_frontend* fe, u16* snr)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        *snr = 0xFFFF -
-            ((at76c651_readreg(state, 0x8F) << 8) |
-             at76c651_readreg(state, 0x90));
-        return 0;
-}
-static int at76c651_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        *ucblocks = at76c651_readreg(state, 0x82);
-        return 0;
-}
-static int at76c651_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *fesettings)
-{
-        fesettings->min_delay_ms = 50;
-        fesettings->step_size = 0;
-        fesettings->max_drift = 0;
-        return 0;
-}
-static void at76c651_release(struct dvb_frontend* fe)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        kfree(state);
-}
-static struct dvb_frontend_ops at76c651_ops;
-struct dvb_frontend* at76c651_attach(const struct at76c651_config* config,
-                                     struct i2c_adapter* i2c)
-{
-        struct at76c651_state* state = NULL;
-        /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct at76c651_state), GFP_KERNEL);
-        if (state == NULL) goto error;
-        /* setup the state */
-        state->config = config;
-        state->qam = 0;
-        /* check if the demod is there */
-        if (at76c651_readreg(state, 0x0e) != 0x65) goto error;
-        /* finalise state setup */
-        state->i2c = i2c;
-        state->revision = at76c651_readreg(state, 0x0f) & 0xfe;
-        memcpy(&state->ops, &at76c651_ops, sizeof(struct dvb_frontend_ops));
-        /* create dvb_frontend */
-        state->frontend.ops = &state->ops;
-        state->frontend.demodulator_priv = state;
-        return &state->frontend;
-error:
-        kfree(state);
-        return NULL;
-}
-static struct dvb_frontend_ops at76c651_ops = {
-        .info = {
-                .name = "Atmel AT76C651B DVB-C",
-                .type = FE_QAM,
-                .frequency_min = 48250000,
-                .frequency_max = 863250000,
-                .frequency_stepsize = 62500,
-                /*.frequency_tolerance = */     /* FIXME: 12% of SR */
-                .symbol_rate_min = 0,           /* FIXME */
-                .symbol_rate_max = 9360000,     /* FIXME */
-                .symbol_rate_tolerance = 4000,
-                .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_32 | FE_CAN_QAM_64 | FE_CAN_QAM_128 |
-                    FE_CAN_MUTE_TS | FE_CAN_QAM_256 | FE_CAN_RECOVER
-        },
-        .release = at76c651_release,
-        .init = at76c651_set_defaults,
-        .set_frontend = at76c651_set_parameters,
-        .get_tune_settings = at76c651_get_tune_settings,
-        .read_status = at76c651_read_status,
-        .read_ber = at76c651_read_ber,
-        .read_signal_strength = at76c651_read_signal_strength,
-        .read_snr = at76c651_read_snr,
-        .read_ucblocks = at76c651_read_ucblocks,
-};
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
-MODULE_DESCRIPTION("Atmel AT76C651 DVB-C Demodulator Driver");
-MODULE_AUTHOR("Andreas Oberritter <obi@linuxtv.org>");
-MODULE_LICENSE("GPL");
-EXPORT_SYMBOL(at76c651_attach);
diff --git a/drivers/media/dvb/frontends/at76c651.h b/drivers/media/dvb/frontends/at76c651.h
deleted file mode 100644
index 34054df93608..000000000000
--- a/drivers/media/dvb/frontends/at76c651.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * at76c651.c
- *
- * Atmel DVB-C Frontend Driver (at76c651)
- *
- * Copyright (C) 2001 fnbrd <fnbrd@gmx.de>
- *             & 2002-2004 Andreas Oberritter <obi@linuxtv.org>
- *             & 2003 Wolfram Joost <dbox2@frokaschwei.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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * AT76C651
- * http://www.nalanda.nitc.ac.in/industry/datasheets/atmel/acrobat/doc1293.pdf
- * http://www.atmel.com/atmel/acrobat/doc1320.pdf
- */
-#ifndef AT76C651_H
-#define AT76C651_H
-#include <linux/dvb/frontend.h>
-struct at76c651_config
-{
-        /* the demodulator's i2c address */
-        u8 demod_address;
-        /* PLL maintenance */
-        int (*pll_init)(struct dvb_frontend* fe);
-        int (*pll_set)(struct dvb_frontend* fe, struct dvb_frontend_parameters* params);
-};
-extern struct dvb_frontend* at76c651_attach(const struct at76c651_config* config,
-                                            struct i2c_adapter* i2c);
-#endif // AT76C651_H
diff --git a/drivers/media/dvb/frontends/dvb-pll.c b/drivers/media/dvb/frontends/dvb-pll.c
index 1b9934ea5b06..4dcb6050d4fa 100644
--- a/drivers/media/dvb/frontends/dvb-pll.c
+++ b/drivers/media/dvb/frontends/dvb-pll.c
@@ -326,11 +326,11 @@ struct dvb_pll_desc dvb_pll_tuv1236d = {
 };
 EXPORT_SYMBOL(dvb_pll_tuv1236d);
-/* Samsung TBMV30111IN
+/* Samsung TBMV30111IN / TBMV30712IN1
 * used in Air2PC ATSC - 2nd generation (nxt2002)
 */
-struct dvb_pll_desc dvb_pll_tbmv30111in = {
+struct dvb_pll_desc dvb_pll_samsung_tbmv = {
-        .name = "Samsung TBMV30111IN",
+        .name = "Samsung TBMV30111IN / TBMV30712IN1",
        .min = 54000000,
        .max = 860000000,
        .count = 6,
@@ -343,7 +343,7 @@ struct dvb_pll_desc dvb_pll_tbmv30111in = {
                { 999999999, 44000000, 166666, 0xfc, 0x02 },
        }
 };
-EXPORT_SYMBOL(dvb_pll_tbmv30111in);
+EXPORT_SYMBOL(dvb_pll_samsung_tbmv);
 /*
 * Philips SD1878 Tuner.
diff --git a/drivers/media/dvb/frontends/dvb-pll.h b/drivers/media/dvb/frontends/dvb-pll.h
index f682c09189b3..bb8d4b4eb183 100644
--- a/drivers/media/dvb/frontends/dvb-pll.h
+++ b/drivers/media/dvb/frontends/dvb-pll.h
@@ -38,7 +38,7 @@ extern struct dvb_pll_desc dvb_pll_tded4;
 extern struct dvb_pll_desc dvb_pll_tuv1236d;
 extern struct dvb_pll_desc dvb_pll_tdhu2;
-extern struct dvb_pll_desc dvb_pll_tbmv30111in;
+extern struct dvb_pll_desc dvb_pll_samsung_tbmv;
 extern struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261;
 int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf,
diff --git a/drivers/media/dvb/frontends/nxt2002.c b/drivers/media/dvb/frontends/nxt2002.c
deleted file mode 100644
index 4f263e65ba14..000000000000
--- a/drivers/media/dvb/frontends/nxt2002.c
+++ /dev/null
@@ -1,706 +0,0 @@
-/*
-    Support for B2C2/BBTI Technisat Air2PC - ATSC
-    Copyright (C) 2004 Taylor Jacob <rtjacob@earthlink.net>
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-/*
- * This driver needs external firmware. Please use the command
- * "<kerneldir>/Documentation/dvb/get_dvb_firmware nxt2002" to
- * download/extract it, and then copy it to /usr/lib/hotplug/firmware
- * or /lib/firmware (depending on configuration of firmware hotplug).
- */
-#define NXT2002_DEFAULT_FIRMWARE "dvb-fe-nxt2002.fw"
-#define CRC_CCIT_MASK 0x1021
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/device.h>
-#include <linux/firmware.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include "dvb_frontend.h"
-#include "nxt2002.h"
-struct nxt2002_state {
-        struct i2c_adapter* i2c;
-        struct dvb_frontend_ops ops;
-        const struct nxt2002_config* config;
-        struct dvb_frontend frontend;
-        /* demodulator private data */
-        u8 initialised:1;
-};
-static int debug;
-#define dprintk(args...) \
-        do { \
-                if (debug) printk(KERN_DEBUG "nxt2002: " args); \
-        } while (0)
-static int i2c_writebytes (struct nxt2002_state* state, u8 reg, u8 *buf, u8 len)
-{
-        /* probbably a much better way or doing this */
-        u8 buf2 [256],x;
-        int err;
-        struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf2, .len = len + 1 };
-        buf2[0] = reg;
-        for (x = 0 ; x < len ; x++)
-                buf2[x+1] = buf[x];
-        if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
-                printk ("%s: i2c write error (addr %02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, err);
-                return -EREMOTEIO;
-        }
-        return 0;
-}
-static u8 i2c_readbytes (struct nxt2002_state* state, u8 reg, u8* buf, u8 len)
-{
-        u8 reg2 [] = { reg };
-        struct i2c_msg msg [] = { { .addr = state->config->demod_address, .flags = 0, .buf = reg2, .len = 1 },
-                        { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = buf, .len = len } };
-        int err;
-        if ((err = i2c_transfer (state->i2c, msg, 2)) != 2) {
-                printk ("%s: i2c read error (addr %02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, err);
-                return -EREMOTEIO;
-        }
-        return 0;
-}
-static u16 nxt2002_crc(u16 crc, u8 c)
-{
-        u8 i;
-        u16 input = (u16) c & 0xFF;
-        input<<=8;
-        for(i=0 ;i<8 ;i++) {
-                if((crc ^ input) & 0x8000)
-                        crc=(crc<<1)^CRC_CCIT_MASK;
-                else
-                        crc<<=1;
-        input<<=1;
-        }
-        return crc;
-}
-static int nxt2002_writereg_multibyte (struct nxt2002_state* state, u8 reg, u8* data, u8 len)
-{
-        u8 buf;
-        dprintk("%s\n", __FUNCTION__);
-        /* set multi register length */
-        i2c_writebytes(state,0x34,&len,1);
-        /* set mutli register register */
-        i2c_writebytes(state,0x35,&reg,1);
-        /* send the actual data */
-        i2c_writebytes(state,0x36,data,len);
-        /* toggle the multireg write bit*/
-        buf = 0x02;
-        i2c_writebytes(state,0x21,&buf,1);
-        i2c_readbytes(state,0x21,&buf,1);
-        if ((buf & 0x02) == 0)
-                return 0;
-        dprintk("Error writing multireg register %02X\n",reg);
-        return 0;
-}
-static int nxt2002_readreg_multibyte (struct nxt2002_state* state, u8 reg, u8* data, u8 len)
-{
-        u8 len2;
-        dprintk("%s\n", __FUNCTION__);
-        /* set multi register length */
-        len2 = len & 0x80;
-        i2c_writebytes(state,0x34,&len2,1);
-        /* set mutli register register */
-        i2c_writebytes(state,0x35,&reg,1);
-        /* send the actual data */
-        i2c_readbytes(state,reg,data,len);
-        return 0;
-}
-static void nxt2002_microcontroller_stop (struct nxt2002_state* state)
-{
-        u8 buf[2],counter = 0;
-        dprintk("%s\n", __FUNCTION__);
-        buf[0] = 0x80;
-        i2c_writebytes(state,0x22,buf,1);
-        while (counter < 20) {
-                i2c_readbytes(state,0x31,buf,1);
-                if (buf[0] & 0x40)
-                        return;
-                msleep(10);
-                counter++;
-        }
-        dprintk("Timeout waiting for micro to stop.. This is ok after firmware upload\n");
-        return;
-}
-static void nxt2002_microcontroller_start (struct nxt2002_state* state)
-{
-        u8 buf;
-        dprintk("%s\n", __FUNCTION__);
-        buf = 0x00;
-        i2c_writebytes(state,0x22,&buf,1);
-}
-static int nxt2002_writetuner (struct nxt2002_state* state, u8* data)
-{
-        u8 buf,count = 0;
-        dprintk("Tuner Bytes: %02X %02X %02X %02X\n",data[0],data[1],data[2],data[3]);
-        dprintk("%s\n", __FUNCTION__);
-        /* stop the micro first */
-        nxt2002_microcontroller_stop(state);
-        /* set the i2c transfer speed to the tuner */
-        buf = 0x03;
-        i2c_writebytes(state,0x20,&buf,1);
-        /* setup to transfer 4 bytes via i2c */
-        buf = 0x04;
-        i2c_writebytes(state,0x34,&buf,1);
-        /* write actual tuner bytes */
-        i2c_writebytes(state,0x36,data,4);
-        /* set tuner i2c address */
-        buf = 0xC2;
-        i2c_writebytes(state,0x35,&buf,1);
-        /* write UC Opmode to begin transfer */
-        buf = 0x80;
-        i2c_writebytes(state,0x21,&buf,1);
-        while (count < 20) {
-                i2c_readbytes(state,0x21,&buf,1);
-                if ((buf & 0x80)== 0x00)
-                        return 0;
-                msleep(100);
-                count++;
-        }
-        printk("nxt2002: timeout error writing tuner\n");
-        return 0;
-}
-static void nxt2002_agc_reset(struct nxt2002_state* state)
-{
-        u8 buf;
-        dprintk("%s\n", __FUNCTION__);
-        buf = 0x08;
-        i2c_writebytes(state,0x08,&buf,1);
-        buf = 0x00;
-        i2c_writebytes(state,0x08,&buf,1);
-        return;
-}
-static int nxt2002_load_firmware (struct dvb_frontend* fe, const struct firmware *fw)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 buf[256],written = 0,chunkpos = 0;
-        u16 rambase,position,crc = 0;
-        dprintk("%s\n", __FUNCTION__);
-        dprintk("Firmware is %zu bytes\n",fw->size);
-        /* Get the RAM base for this nxt2002 */
-        i2c_readbytes(state,0x10,buf,1);
-        if (buf[0] & 0x10)
-                rambase = 0x1000;
-        else
-                rambase = 0x0000;
-        dprintk("rambase on this nxt2002 is %04X\n",rambase);
-        /* Hold the micro in reset while loading firmware */
-        buf[0] = 0x80;
-        i2c_writebytes(state,0x2B,buf,1);
-        for (position = 0; position < fw->size ; position++) {
-                if (written == 0) {
-                        crc = 0;
-                        chunkpos = 0x28;
-                        buf[0] = ((rambase + position) >> 8);
-                        buf[1] = (rambase + position) & 0xFF;
-                        buf[2] = 0x81;
-                        /* write starting address */
-                        i2c_writebytes(state,0x29,buf,3);
-                }
-                written++;
-                chunkpos++;
-                if ((written % 4) == 0)
-                        i2c_writebytes(state,chunkpos,&fw->data[position-3],4);
-                crc = nxt2002_crc(crc,fw->data[position]);
-                if ((written == 255) || (position+1 == fw->size)) {
-                        /* write remaining bytes of firmware */
-                        i2c_writebytes(state, chunkpos+4-(written %4),
-                                &fw->data[position-(written %4) + 1],
-                                written %4);
-                        buf[0] = crc << 8;
-                        buf[1] = crc & 0xFF;
-                        /* write crc */
-                        i2c_writebytes(state,0x2C,buf,2);
-                        /* do a read to stop things */
-                        i2c_readbytes(state,0x2A,buf,1);
-                        /* set transfer mode to complete */
-                        buf[0] = 0x80;
-                        i2c_writebytes(state,0x2B,buf,1);
-                        written = 0;
-                }
-        }
-        printk ("done.\n");
-        return 0;
-};
-static int nxt2002_setup_frontend_parameters (struct dvb_frontend* fe,
-                                             struct dvb_frontend_parameters *p)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u32 freq = 0;
-        u16 tunerfreq = 0;
-        u8 buf[4];
-        freq = 44000 + ( p->frequency / 1000 );
-        dprintk("freq = %d      p->frequency = %d\n",freq,p->frequency);
-        tunerfreq = freq * 24/4000;
-        buf[0] = (tunerfreq >> 8) & 0x7F;
-        buf[1] = (tunerfreq & 0xFF);
-        if (p->frequency <= 214000000) {
-                buf[2] = 0x84 + (0x06 << 3);
-                buf[3] = (p->frequency <= 172000000) ? 0x01 : 0x02;
-        } else if (p->frequency <= 721000000) {
-                buf[2] = 0x84 + (0x07 << 3);
-                buf[3] = (p->frequency <= 467000000) ? 0x02 : 0x08;
-        } else if (p->frequency <= 841000000) {
-                buf[2] = 0x84 + (0x0E << 3);
-                buf[3] = 0x08;
-        } else {
-                buf[2] = 0x84 + (0x0F << 3);
-                buf[3] = 0x02;
-        }
-        /* write frequency information */
-        nxt2002_writetuner(state,buf);
-        /* reset the agc now that tuning has been completed */
-        nxt2002_agc_reset(state);
-        /* set target power level */
-        switch (p->u.vsb.modulation) {
-                case QAM_64:
-                case QAM_256:
-                                buf[0] = 0x74;
-                                break;
-                case VSB_8:
-                                buf[0] = 0x70;
-                                break;
-                default:
-                                return -EINVAL;
-                                break;
-        }
-        i2c_writebytes(state,0x42,buf,1);
-        /* configure sdm */
-        buf[0] = 0x87;
-        i2c_writebytes(state,0x57,buf,1);
-        /* write sdm1 input */
-        buf[0] = 0x10;
-        buf[1] = 0x00;
-        nxt2002_writereg_multibyte(state,0x58,buf,2);
-        /* write sdmx input */
-        switch (p->u.vsb.modulation) {
-                case QAM_64:
-                                buf[0] = 0x68;
-                                break;
-                case QAM_256:
-                                buf[0] = 0x64;
-                                break;
-                case VSB_8:
-                                buf[0] = 0x60;
-                                break;
-                default:
-                                return -EINVAL;
-                                break;
-        }
-        buf[1] = 0x00;
-        nxt2002_writereg_multibyte(state,0x5C,buf,2);
-        /* write adc power lpf fc */
-        buf[0] = 0x05;
-        i2c_writebytes(state,0x43,buf,1);
-        /* write adc power lpf fc */
-        buf[0] = 0x05;
-        i2c_writebytes(state,0x43,buf,1);
-        /* write accumulator2 input */
-        buf[0] = 0x80;
-        buf[1] = 0x00;
-        nxt2002_writereg_multibyte(state,0x4B,buf,2);
-        /* write kg1 */
-        buf[0] = 0x00;
-        i2c_writebytes(state,0x4D,buf,1);
-        /* write sdm12 lpf fc */
-        buf[0] = 0x44;
-        i2c_writebytes(state,0x55,buf,1);
-        /* write agc control reg */
-        buf[0] = 0x04;
-        i2c_writebytes(state,0x41,buf,1);
-        /* write agc ucgp0 */
-        switch (p->u.vsb.modulation) {
-                case QAM_64:
-                                buf[0] = 0x02;
-                                break;
-                case QAM_256:
-                                buf[0] = 0x03;
-                                break;
-                case VSB_8:
-                                buf[0] = 0x00;
-                                break;
-                default:
-                                return -EINVAL;
-                                break;
-        }
-        i2c_writebytes(state,0x30,buf,1);
-        /* write agc control reg */
-        buf[0] = 0x00;
-        i2c_writebytes(state,0x41,buf,1);
-        /* write accumulator2 input */
-        buf[0] = 0x80;
-        buf[1] = 0x00;
-        nxt2002_writereg_multibyte(state,0x49,buf,2);
-        nxt2002_writereg_multibyte(state,0x4B,buf,2);
-        /* write agc control reg */
-        buf[0] = 0x04;
-        i2c_writebytes(state,0x41,buf,1);
-        nxt2002_microcontroller_start(state);
-        /* adjacent channel detection should be done here, but I don't
-        have any stations with this need so I cannot test it */
-        return 0;
-}
-static int nxt2002_read_status(struct dvb_frontend* fe, fe_status_t* status)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 lock;
-        i2c_readbytes(state,0x31,&lock,1);
-        *status = 0;
-        if (lock & 0x20) {
-                *status |= FE_HAS_SIGNAL;
-                *status |= FE_HAS_CARRIER;
-                *status |= FE_HAS_VITERBI;
-                *status |= FE_HAS_SYNC;
-                *status |= FE_HAS_LOCK;
-        }
-        return 0;
-}
-static int nxt2002_read_ber(struct dvb_frontend* fe, u32* ber)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 b[3];
-        nxt2002_readreg_multibyte(state,0xE6,b,3);
-        *ber = ((b[0] << 8) + b[1]) * 8;
-        return 0;
-}
-static int nxt2002_read_signal_strength(struct dvb_frontend* fe, u16* strength)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 b[2];
-        u16 temp = 0;
-        /* setup to read cluster variance */
-        b[0] = 0x00;
-        i2c_writebytes(state,0xA1,b,1);
-        /* get multreg val */
-        nxt2002_readreg_multibyte(state,0xA6,b,2);
-        temp = (b[0] << 8) | b[1];
-        *strength = ((0x7FFF - temp) & 0x0FFF) * 16;
-        return 0;
-}
-static int nxt2002_read_snr(struct dvb_frontend* fe, u16* snr)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 b[2];
-        u16 temp = 0, temp2;
-        u32 snrdb = 0;
-        /* setup to read cluster variance */
-        b[0] = 0x00;
-        i2c_writebytes(state,0xA1,b,1);
-        /* get multreg val from 0xA6 */
-        nxt2002_readreg_multibyte(state,0xA6,b,2);
-        temp = (b[0] << 8) | b[1];
-        temp2 = 0x7FFF - temp;
-        /* snr will be in db */
-        if (temp2 > 0x7F00)
-                snrdb = 1000*24 + ( 1000*(30-24) * ( temp2 - 0x7F00 ) / ( 0x7FFF - 0x7F00 ) );
-        else if (temp2 > 0x7EC0)
-                snrdb = 1000*18 + ( 1000*(24-18) * ( temp2 - 0x7EC0 ) / ( 0x7F00 - 0x7EC0 ) );
-        else if (temp2 > 0x7C00)
-                snrdb = 1000*12 + ( 1000*(18-12) * ( temp2 - 0x7C00 ) / ( 0x7EC0 - 0x7C00 ) );
-        else
-                snrdb = 1000*0 + ( 1000*(12-0) * ( temp2 - 0 ) / ( 0x7C00 - 0 ) );
-        /* the value reported back from the frontend will be FFFF=32db 0000=0db */
-        *snr = snrdb * (0xFFFF/32000);
-        return 0;
-}
-static int nxt2002_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 b[3];
-        nxt2002_readreg_multibyte(state,0xE6,b,3);
-        *ucblocks = b[2];
-        return 0;
-}
-static int nxt2002_sleep(struct dvb_frontend* fe)
-{
-        return 0;
-}
-static int nxt2002_init(struct dvb_frontend* fe)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        const struct firmware *fw;
-        int ret;
-        u8 buf[2];
-        if (!state->initialised) {
-                /* request the firmware, this will block until someone uploads it */
-                printk("nxt2002: Waiting for firmware upload (%s)...\n", NXT2002_DEFAULT_FIRMWARE);
-                ret = state->config->request_firmware(fe, &fw, NXT2002_DEFAULT_FIRMWARE);
-                printk("nxt2002: Waiting for firmware upload(2)...\n");
-                if (ret) {
-                        printk("nxt2002: no firmware upload (timeout or file not found?)\n");
-                        return ret;
-                }
-                ret = nxt2002_load_firmware(fe, fw);
-                if (ret) {
-                        printk("nxt2002: writing firmware to device failed\n");
-                        release_firmware(fw);
-                        return ret;
-                }
-                printk("nxt2002: firmware upload complete\n");
-                /* Put the micro into reset */
-                nxt2002_microcontroller_stop(state);
-                /* ensure transfer is complete */
-                buf[0]=0;
-                i2c_writebytes(state,0x2B,buf,1);
-                /* Put the micro into reset for real this time */
-                nxt2002_microcontroller_stop(state);
-                /* soft reset everything (agc,frontend,eq,fec)*/
-                buf[0] = 0x0F;
-                i2c_writebytes(state,0x08,buf,1);
-                buf[0] = 0x00;
-                i2c_writebytes(state,0x08,buf,1);
-                /* write agc sdm configure */
-                buf[0] = 0xF1;
-                i2c_writebytes(state,0x57,buf,1);
-                /* write mod output format */
-                buf[0] = 0x20;
-                i2c_writebytes(state,0x09,buf,1);
-                /* write fec mpeg mode */
-                buf[0] = 0x7E;
-                buf[1] = 0x00;
-                i2c_writebytes(state,0xE9,buf,2);
-                /* write mux selection */
-                buf[0] = 0x00;
-                i2c_writebytes(state,0xCC,buf,1);
-                state->initialised = 1;
-        }
-        return 0;
-}
-static int nxt2002_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
-{
-        fesettings->min_delay_ms = 500;
-        fesettings->step_size = 0;
-        fesettings->max_drift = 0;
-        return 0;
-}
-static void nxt2002_release(struct dvb_frontend* fe)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        kfree(state);
-}
-static struct dvb_frontend_ops nxt2002_ops;
-struct dvb_frontend* nxt2002_attach(const struct nxt2002_config* config,
-                                   struct i2c_adapter* i2c)
-{
-        struct nxt2002_state* state = NULL;
-        u8 buf [] = {0,0,0,0,0};
-        /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct nxt2002_state), GFP_KERNEL);
-        if (state == NULL) goto error;
-        /* setup the state */
-        state->config = config;
-        state->i2c = i2c;
-        memcpy(&state->ops, &nxt2002_ops, sizeof(struct dvb_frontend_ops));
-        state->initialised = 0;
-        /* Check the first 5 registers to ensure this a revision we can handle */
-        i2c_readbytes(state, 0x00, buf, 5);
-        if (buf[0] != 0x04) goto error;         /* device id */
-        if (buf[1] != 0x02) goto error;         /* fab id */
-        if (buf[2] != 0x11) goto error;         /* month */
-        if (buf[3] != 0x20) goto error;         /* year msb */
-        if (buf[4] != 0x00) goto error;         /* year lsb */
-        /* create dvb_frontend */
-        state->frontend.ops = &state->ops;
-        state->frontend.demodulator_priv = state;
-        return &state->frontend;
-error:
-        kfree(state);
-        return NULL;
-}
-static struct dvb_frontend_ops nxt2002_ops = {
-        .info = {
-                .name = "Nextwave nxt2002 VSB/QAM frontend",
-                .type = FE_ATSC,
-                .frequency_min =  54000000,
-                .frequency_max = 860000000,
-                /* stepsize is just a guess */
-                .frequency_stepsize = 166666,
-                .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_FEC_AUTO |
-                        FE_CAN_8VSB | FE_CAN_QAM_64 | FE_CAN_QAM_256
-        },
-        .release = nxt2002_release,
-        .init = nxt2002_init,
-        .sleep = nxt2002_sleep,
-        .set_frontend = nxt2002_setup_frontend_parameters,
-        .get_tune_settings = nxt2002_get_tune_settings,
-        .read_status = nxt2002_read_status,
-        .read_ber = nxt2002_read_ber,
-        .read_signal_strength = nxt2002_read_signal_strength,
-        .read_snr = nxt2002_read_snr,
-        .read_ucblocks = nxt2002_read_ucblocks,
-};
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
-MODULE_DESCRIPTION("NXT2002 ATSC (8VSB & ITU J83 AnnexB FEC QAM64/256) demodulator driver");
-MODULE_AUTHOR("Taylor Jacob");
-MODULE_LICENSE("GPL");
-EXPORT_SYMBOL(nxt2002_attach);
diff --git a/drivers/media/dvb/frontends/nxt2002.h b/drivers/media/dvb/frontends/nxt2002.h
deleted file mode 100644
index 462301f577ee..000000000000
--- a/drivers/media/dvb/frontends/nxt2002.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-   Driver for the Nxt2002 demodulator
-*/
-#ifndef NXT2002_H
-#define NXT2002_H
-#include <linux/dvb/frontend.h>
-#include <linux/firmware.h>
-struct nxt2002_config
-{
-        /* the demodulator's i2c address */
-        u8 demod_address;
-        /* request firmware for device */
-        int (*request_firmware)(struct dvb_frontend* fe, const struct firmware **fw, char* name);
-};
-extern struct dvb_frontend* nxt2002_attach(const struct nxt2002_config* config,
-                                           struct i2c_adapter* i2c);
-#endif // NXT2002_H
diff --git a/drivers/media/dvb/frontends/nxt200x.c b/drivers/media/dvb/frontends/nxt200x.c
index 78d2b93d35b9..9e3535394509 100644
--- a/drivers/media/dvb/frontends/nxt200x.c
+++ b/drivers/media/dvb/frontends/nxt200x.c
@@ -1,9 +1,10 @@
 /*
 *    Support for NXT2002 and NXT2004 - VSB/QAM
 *
- *    Copyright (C) 2005 Kirk Lapray (kirk.lapray@gmail.com)
+ *    Copyright (C) 2005 Kirk Lapray <kirk.lapray@gmail.com>
+ *    Copyright (C) 2006 Michael Krufky <mkrufky@m1k.net>
 *    based on nxt2002 by Taylor Jacob <rtjacob@earthlink.net>
- *    and nxt2004 by Jean-Francois Thibert (jeanfrancois@sagetv.com)
+ *    and nxt2004 by Jean-Francois Thibert <jeanfrancois@sagetv.com>
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
@@ -614,7 +615,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe,
        /* write sdm1 input */
        buf[0] = 0x10;
        buf[1] = 0x00;
-        nxt200x_writebytes(state, 0x58, buf, 2);
+        switch (state->demod_chip) {
+                case NXT2002:
+                        nxt200x_writereg_multibyte(state, 0x58, buf, 2);
+                        break;
+                case NXT2004:
+                        nxt200x_writebytes(state, 0x58, buf, 2);
+                        break;
+                default:
+                        return -EINVAL;
+                        break;
+        }
        /* write sdmx input */
        switch (p->u.vsb.modulation) {
@@ -632,7 +643,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe,
                                break;
        }
        buf[1] = 0x00;
-        nxt200x_writebytes(state, 0x5C, buf, 2);
+        switch (state->demod_chip) {
+                case NXT2002:
+                        nxt200x_writereg_multibyte(state, 0x5C, buf, 2);
+                        break;
+                case NXT2004:
+                        nxt200x_writebytes(state, 0x5C, buf, 2);
+                        break;
+                default:
+                        return -EINVAL;
+                        break;
+        }
        /* write adc power lpf fc */
        buf[0] = 0x05;
@@ -648,7 +669,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe,
        /* write accumulator2 input */
        buf[0] = 0x80;
        buf[1] = 0x00;
-        nxt200x_writebytes(state, 0x4B, buf, 2);
+        switch (state->demod_chip) {
+                case NXT2002:
+                        nxt200x_writereg_multibyte(state, 0x4B, buf, 2);
+                        break;
+                case NXT2004:
+                        nxt200x_writebytes(state, 0x4B, buf, 2);
+                        break;
+                default:
+                        return -EINVAL;
+                        break;
+        }
        /* write kg1 */
        buf[0] = 0x00;
@@ -714,8 +745,19 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe,
        /* write accumulator2 input */
        buf[0] = 0x80;
        buf[1] = 0x00;
-        nxt200x_writebytes(state, 0x49, buf,2);
+        switch (state->demod_chip) {
-        nxt200x_writebytes(state, 0x4B, buf,2);
+                case NXT2002:
+                        nxt200x_writereg_multibyte(state, 0x49, buf, 2);
+                        nxt200x_writereg_multibyte(state, 0x4B, buf, 2);
+                        break;
+                case NXT2004:
+                        nxt200x_writebytes(state, 0x49, buf, 2);
+                        nxt200x_writebytes(state, 0x4B, buf, 2);
+                        break;
+                default:
+                        return -EINVAL;
+                        break;
+        }
        /* write agc control reg */
        buf[0] = 0x04;
@@ -1199,7 +1241,7 @@ module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 MODULE_DESCRIPTION("NXT200X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver");
-MODULE_AUTHOR("Kirk Lapray, Jean-Francois Thibert, and Taylor Jacob");
+MODULE_AUTHOR("Kirk Lapray, Michael Krufky, Jean-Francois Thibert, and Taylor Jacob");
 MODULE_LICENSE("GPL");
 EXPORT_SYMBOL(nxt200x_attach);
diff --git a/drivers/media/dvb/frontends/tda80xx.c b/drivers/media/dvb/frontends/tda80xx.c
deleted file mode 100644
index d1cabb6a0a13..000000000000
--- a/drivers/media/dvb/frontends/tda80xx.c
+++ /dev/null
@@ -1,734 +0,0 @@
-/*
- * tda80xx.c
- *
- * Philips TDA8044 / TDA8083 QPSK demodulator driver
- *
- * Copyright (C) 2001 Felix Domke <tmbinc@elitedvb.net>
- * Copyright (C) 2002-2004 Andreas Oberritter <obi@linuxtv.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#include <linux/config.h>
-#include <linux/delay.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/threads.h>
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <asm/irq.h>
-#include <asm/div64.h>
-#include "dvb_frontend.h"
-#include "tda80xx.h"
-enum {
-        ID_TDA8044 = 0x04,
-        ID_TDA8083 = 0x05,
-};
-struct tda80xx_state {
-        struct i2c_adapter* i2c;
-        struct dvb_frontend_ops ops;
-        /* configuration settings */
-        const struct tda80xx_config* config;
-        struct dvb_frontend frontend;
-        u32 clk;
-        int afc_loop;
-        struct work_struct worklet;
-        fe_code_rate_t code_rate;
-        fe_spectral_inversion_t spectral_inversion;
-        fe_status_t status;
-        u8 id;
-};
-static int debug = 1;
-#define dprintk if (debug) printk
-static u8 tda8044_inittab_pre[] = {
-        0x02, 0x00, 0x6f, 0xb5, 0x86, 0x22, 0x00, 0xea,
-        0x30, 0x42, 0x98, 0x68, 0x70, 0x42, 0x99, 0x58,
-        0x95, 0x10, 0xf5, 0xe7, 0x93, 0x0b, 0x15, 0x68,
-        0x9a, 0x90, 0x61, 0x80, 0x00, 0xe0, 0x40, 0x00,
-        0x0f, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00
-};
-static u8 tda8044_inittab_post[] = {
-        0x04, 0x00, 0x6f, 0xb5, 0x86, 0x22, 0x00, 0xea,
-        0x30, 0x42, 0x98, 0x68, 0x70, 0x42, 0x99, 0x50,
-        0x95, 0x10, 0xf5, 0xe7, 0x93, 0x0b, 0x15, 0x68,
-        0x9a, 0x90, 0x61, 0x80, 0x00, 0xe0, 0x40, 0x6c,
-        0x0f, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00
-};
-static u8 tda8083_inittab[] = {
-        0x04, 0x00, 0x4a, 0x79, 0x04, 0x00, 0xff, 0xea,
-        0x48, 0x42, 0x79, 0x60, 0x70, 0x52, 0x9a, 0x10,
-        0x0e, 0x10, 0xf2, 0xa7, 0x93, 0x0b, 0x05, 0xc8,
-        0x9d, 0x00, 0x42, 0x80, 0x00, 0x60, 0x40, 0x00,
-        0x00, 0x75, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00
-};
-static __inline__ u32 tda80xx_div(u32 a, u32 b)
-{
-        return (a + (b / 2)) / b;
-}
-static __inline__ u32 tda80xx_gcd(u32 a, u32 b)
-{
-        u32 r;
-        while ((r = a % b)) {
-                a = b;
-                b = r;
-        }
-        return b;
-}
-static int tda80xx_read(struct tda80xx_state* state, u8 reg, u8 *buf, u8 len)
-{
-        int ret;
-        struct i2c_msg msg[] = { { .addr = state->config->demod_address, .flags = 0, .buf = &reg, .len = 1 },
-                          { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = buf, .len = len } };
-        ret = i2c_transfer(state->i2c, msg, 2);
-        if (ret != 2)
-                dprintk("%s: readreg error (reg %02x, ret == %i)\n",
-                                __FUNCTION__, reg, ret);
-        mdelay(10);
-        return (ret == 2) ? 0 : -EREMOTEIO;
-}
-static int tda80xx_write(struct tda80xx_state* state, u8 reg, const u8 *buf, u8 len)
-{
-        int ret;
-        u8 wbuf[len + 1];
-        struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = wbuf, .len = len + 1 };
-        wbuf[0] = reg;
-        memcpy(&wbuf[1], buf, len);
-        ret = i2c_transfer(state->i2c, &msg, 1);
-        if (ret != 1)
-                dprintk("%s: i2c xfer error (ret == %i)\n", __FUNCTION__, ret);
-        mdelay(10);
-        return (ret == 1) ? 0 : -EREMOTEIO;
-}
-static __inline__ u8 tda80xx_readreg(struct tda80xx_state* state, u8 reg)
-{
-        u8 val;
-        tda80xx_read(state, reg, &val, 1);
-        return val;
-}
-static __inline__ int tda80xx_writereg(struct tda80xx_state* state, u8 reg, u8 data)
-{
-        return tda80xx_write(state, reg, &data, 1);
-}
-static int tda80xx_set_parameters(struct tda80xx_state* state,
-                                  fe_spectral_inversion_t inversion,
-                                  u32 symbol_rate,
-                                  fe_code_rate_t fec_inner)
-{
-        u8 buf[15];
-        u64 ratio;
-        u32 clk;
-        u32 k;
-        u32 sr = symbol_rate;
-        u32 gcd;
-        u8 scd;
-        if (symbol_rate > (state->clk * 3) / 16)
-                scd = 0;
-        else if (symbol_rate > (state->clk * 3) / 32)
-                scd = 1;
-        else if (symbol_rate > (state->clk * 3) / 64)
-                scd = 2;
-        else
-                scd = 3;
-        clk = scd ? (state->clk / (scd * 2)) : state->clk;
-        /*
-         * Viterbi decoder:
-         * Differential decoding off
-         * Spectral inversion unknown
-         * QPSK modulation
-         */
-        if (inversion == INVERSION_ON)
-                buf[0] = 0x60;
-        else if (inversion == INVERSION_OFF)
-                buf[0] = 0x20;
-        else
-                buf[0] = 0x00;
-        /*
-         * CLK ratio:
-         * system clock frequency is up to 64 or 96 MHz
-         *
-         * formula:
-         * r = k * clk / symbol_rate
-         *
-         * k:   2^21 for caa 0..3,
-         *      2^20 for caa 4..5,
-         *      2^19 for caa 6..7
-         */
-        if (symbol_rate <= (clk * 3) / 32)
-                k = (1 << 19);
-        else if (symbol_rate <= (clk * 3) / 16)
-                k = (1 << 20);
-        else
-                k = (1 << 21);
-        gcd = tda80xx_gcd(clk, sr);
-        clk /= gcd;
-        sr /= gcd;
-        gcd = tda80xx_gcd(k, sr);
-        k /= gcd;
-        sr /= gcd;
-        ratio = (u64)k * (u64)clk;
-        do_div(ratio, sr);
-        buf[1] = ratio >> 16;
-        buf[2] = ratio >> 8;
-        buf[3] = ratio;
-        /* nyquist filter roll-off factor 35% */
-        buf[4] = 0x20;
-        clk = scd ? (state->clk / (scd * 2)) : state->clk;
-        /* Anti Alias Filter */
-        if (symbol_rate < (clk * 3) / 64)
-                printk("tda80xx: unsupported symbol rate: %u\n", symbol_rate);
-        else if (symbol_rate <= clk / 16)
-                buf[4] |= 0x07;
-        else if (symbol_rate <= (clk * 3) / 32)
-                buf[4] |= 0x06;
-        else if (symbol_rate <= clk / 8)
-                buf[4] |= 0x05;
-        else if (symbol_rate <= (clk * 3) / 16)
-                buf[4] |= 0x04;
-        else if (symbol_rate <= clk / 4)
-                buf[4] |= 0x03;
-        else if (symbol_rate <= (clk * 3) / 8)
-                buf[4] |= 0x02;
-        else if (symbol_rate <= clk / 2)
-                buf[4] |= 0x01;
-        else
-                buf[4] |= 0x00;
-        /* Sigma Delta converter */
-        buf[5] = 0x00;
-        /* FEC: Possible puncturing rates */
-        if (fec_inner == FEC_NONE)
-                buf[6] = 0x00;
-        else if ((fec_inner >= FEC_1_2) && (fec_inner <= FEC_8_9))
-                buf[6] = (1 << (8 - fec_inner));
-        else if (fec_inner == FEC_AUTO)
-                buf[6] = 0xff;
-        else
-                return -EINVAL;
-        /* carrier lock detector threshold value */
-        buf[7] = 0x30;
-        /* AFC1: proportional part settings */
-        buf[8] = 0x42;
-        /* AFC1: integral part settings */
-        buf[9] = 0x98;
-        /* PD: Leaky integrator SCPC mode */
-        buf[10] = 0x28;
-        /* AFC2, AFC1 controls */
-        buf[11] = 0x30;
-        /* PD: proportional part settings */
-        buf[12] = 0x42;
-        /* PD: integral part settings */
-        buf[13] = 0x99;
-        /* AGC */
-        buf[14] = 0x50 | scd;
-        printk("symbol_rate=%u clk=%u\n", symbol_rate, clk);
-        return tda80xx_write(state, 0x01, buf, sizeof(buf));
-}
-static int tda80xx_set_clk(struct tda80xx_state* state)
-{
-        u8 buf[2];
-        /* CLK proportional part */
-        buf[0] = (0x06 << 5) | 0x08;    /* CMP[2:0], CSP[4:0] */
-        /* CLK integral part */
-        buf[1] = (0x04 << 5) | 0x1a;    /* CMI[2:0], CSI[4:0] */
-        return tda80xx_write(state, 0x17, buf, sizeof(buf));
-}
-#if 0
-static int tda80xx_set_scpc_freq_offset(struct tda80xx_state* state)
-{
-        /* a constant value is nonsense here imho */
-        return tda80xx_writereg(state, 0x22, 0xf9);
-}
-#endif
-static int tda80xx_close_loop(struct tda80xx_state* state)
-{
-        u8 buf[2];
-        /* PD: Loop closed, LD: lock detect enable, SCPC: Sweep mode - AFC1 loop closed */
-        buf[0] = 0x68;
-        /* AFC1: Loop closed, CAR Feedback: 8192 */
-        buf[1] = 0x70;
-        return tda80xx_write(state, 0x0b, buf, sizeof(buf));
-}
-static irqreturn_t tda80xx_irq(int irq, void *priv, struct pt_regs *pt)
-{
-        schedule_work(priv);
-        return IRQ_HANDLED;
-}
-static void tda80xx_read_status_int(struct tda80xx_state* state)
-{
-        u8 val;
-        static const fe_spectral_inversion_t inv_tab[] = {
-                INVERSION_OFF, INVERSION_ON
-        };
-        static const fe_code_rate_t fec_tab[] = {
-                FEC_8_9, FEC_1_2, FEC_2_3, FEC_3_4,
-                FEC_4_5, FEC_5_6, FEC_6_7, FEC_7_8,
-        };
-        val = tda80xx_readreg(state, 0x02);
-        state->status = 0;
-        if (val & 0x01) /* demodulator lock */
-                state->status |= FE_HAS_SIGNAL;
-        if (val & 0x02) /* clock recovery lock */
-                state->status |= FE_HAS_CARRIER;
-        if (val & 0x04) /* viterbi lock */
-                state->status |= FE_HAS_VITERBI;
-        if (val & 0x08) /* deinterleaver lock (packet sync) */
-                state->status |= FE_HAS_SYNC;
-        if (val & 0x10) /* derandomizer lock (frame sync) */
-                state->status |= FE_HAS_LOCK;
-        if (val & 0x20) /* frontend can not lock */
-                state->status |= FE_TIMEDOUT;
-        if ((state->status & (FE_HAS_CARRIER)) && (state->afc_loop)) {
-                printk("tda80xx: closing loop\n");
-                tda80xx_close_loop(state);
-                state->afc_loop = 0;
-        }
-        if (state->status & (FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK)) {
-                val = tda80xx_readreg(state, 0x0e);
-                state->code_rate = fec_tab[val & 0x07];
-                if (state->status & (FE_HAS_SYNC | FE_HAS_LOCK))
-                        state->spectral_inversion = inv_tab[(val >> 7) & 0x01];
-                else
-                        state->spectral_inversion = INVERSION_AUTO;
-        }
-        else {
-                state->code_rate = FEC_AUTO;
-        }
-}
-static void tda80xx_worklet(void *priv)
-{
-        struct tda80xx_state *state = priv;
-        tda80xx_writereg(state, 0x00, 0x04);
-        enable_irq(state->config->irq);
-        tda80xx_read_status_int(state);
-}
-static void tda80xx_wait_diseqc_fifo(struct tda80xx_state* state)
-{
-        size_t i;
-        for (i = 0; i < 100; i++) {
-                if (tda80xx_readreg(state, 0x02) & 0x80)
-                        break;
-                msleep(10);
-        }
-}
-static int tda8044_init(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        int ret;
-        /*
-         * this function is a mess...
-         */
-        if ((ret = tda80xx_write(state, 0x00, tda8044_inittab_pre, sizeof(tda8044_inittab_pre))))
-                return ret;
-        tda80xx_writereg(state, 0x0f, 0x50);
-#if 1
-        tda80xx_writereg(state, 0x20, 0x8F);            /* FIXME */
-        tda80xx_writereg(state, 0x20, state->config->volt18setting);    /* FIXME */
-        //tda80xx_writereg(state, 0x00, 0x04);
-        tda80xx_writereg(state, 0x00, 0x0C);
-#endif
-        //tda80xx_writereg(state, 0x00, 0x08); /* Reset AFC1 loop filter */
-        tda80xx_write(state, 0x00, tda8044_inittab_post, sizeof(tda8044_inittab_post));
-        if (state->config->pll_init) {
-                tda80xx_writereg(state, 0x1c, 0x80);
-                state->config->pll_init(fe);
-                tda80xx_writereg(state, 0x1c, 0x00);
-        }
-        return 0;
-}
-static int tda8083_init(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        tda80xx_write(state, 0x00, tda8083_inittab, sizeof(tda8083_inittab));
-        if (state->config->pll_init) {
-                tda80xx_writereg(state, 0x1c, 0x80);
-                state->config->pll_init(fe);
-                tda80xx_writereg(state, 0x1c, 0x00);
-        }
-        return 0;
-}
-static int tda80xx_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        switch (voltage) {
-        case SEC_VOLTAGE_13:
-                return tda80xx_writereg(state, 0x20, state->config->volt13setting);
-        case SEC_VOLTAGE_18:
-                return tda80xx_writereg(state, 0x20, state->config->volt18setting);
-        case SEC_VOLTAGE_OFF:
-                return tda80xx_writereg(state, 0x20, 0);
-        default:
-                return -EINVAL;
-        }
-}
-static int tda80xx_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        switch (tone) {
-        case SEC_TONE_OFF:
-                return tda80xx_writereg(state, 0x29, 0x00);
-        case SEC_TONE_ON:
-                return tda80xx_writereg(state, 0x29, 0x80);
-        default:
-                return -EINVAL;
-        }
-}
-static int tda80xx_send_diseqc_msg(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd *cmd)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        if (cmd->msg_len > 6)
-                return -EINVAL;
-        tda80xx_writereg(state, 0x29, 0x08 | (cmd->msg_len - 3));
-        tda80xx_write(state, 0x23, cmd->msg, cmd->msg_len);
-        tda80xx_writereg(state, 0x29, 0x0c | (cmd->msg_len - 3));
-        tda80xx_wait_diseqc_fifo(state);
-        return 0;
-}
-static int tda80xx_send_diseqc_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t cmd)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        switch (cmd) {
-        case SEC_MINI_A:
-                tda80xx_writereg(state, 0x29, 0x14);
-                break;
-        case SEC_MINI_B:
-                tda80xx_writereg(state, 0x29, 0x1c);
-                break;
-        default:
-                return -EINVAL;
-        }
-        tda80xx_wait_diseqc_fifo(state);
-        return 0;
-}
-static int tda80xx_sleep(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        tda80xx_writereg(state, 0x00, 0x02);    /* enter standby */
-        return 0;
-}
-static int tda80xx_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        tda80xx_writereg(state, 0x1c, 0x80);
-        state->config->pll_set(fe, p);
-        tda80xx_writereg(state, 0x1c, 0x00);
-        tda80xx_set_parameters(state, p->inversion, p->u.qpsk.symbol_rate, p->u.qpsk.fec_inner);
-        tda80xx_set_clk(state);
-        //tda80xx_set_scpc_freq_offset(state);
-        state->afc_loop = 1;
-        return 0;
-}
-static int tda80xx_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        if (!state->config->irq)
-                tda80xx_read_status_int(state);
-        p->inversion = state->spectral_inversion;
-        p->u.qpsk.fec_inner = state->code_rate;
-        return 0;
-}
-static int tda80xx_read_status(struct dvb_frontend* fe, fe_status_t* status)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        if (!state->config->irq)
-                tda80xx_read_status_int(state);
-        *status = state->status;
-        return 0;
-}
-static int tda80xx_read_ber(struct dvb_frontend* fe, u32* ber)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        int ret;
-        u8 buf[3];
-        if ((ret = tda80xx_read(state, 0x0b, buf, sizeof(buf))))
-                return ret;
-        *ber = ((buf[0] & 0x1f) << 16) | (buf[1] << 8) | buf[2];
-        return 0;
-}
-static int tda80xx_read_signal_strength(struct dvb_frontend* fe, u16* strength)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        u8 gain = ~tda80xx_readreg(state, 0x01);
-        *strength = (gain << 8) | gain;
-        return 0;
-}
-static int tda80xx_read_snr(struct dvb_frontend* fe, u16* snr)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        u8 quality = tda80xx_readreg(state, 0x08);
-        *snr = (quality << 8) | quality;
-        return 0;
-}
-static int tda80xx_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        *ucblocks = tda80xx_readreg(state, 0x0f);
-        if (*ucblocks == 0xff)
-                *ucblocks = 0xffffffff;
-        return 0;
-}
-static int tda80xx_init(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        switch(state->id) {
-        case ID_TDA8044:
-                return tda8044_init(fe);
-        case ID_TDA8083:
-                return tda8083_init(fe);
-        }
-        return 0;
-}
-static void tda80xx_release(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        if (state->config->irq)
-                free_irq(state->config->irq, &state->worklet);
-        kfree(state);
-}
-static struct dvb_frontend_ops tda80xx_ops;
-struct dvb_frontend* tda80xx_attach(const struct tda80xx_config* config,
-                                    struct i2c_adapter* i2c)
-{
-        struct tda80xx_state* state = NULL;
-        int ret;
-        /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct tda80xx_state), GFP_KERNEL);
-        if (state == NULL) goto error;
-        /* setup the state */
-        state->config = config;
-        state->i2c = i2c;
-        memcpy(&state->ops, &tda80xx_ops, sizeof(struct dvb_frontend_ops));
-        state->spectral_inversion = INVERSION_AUTO;
-        state->code_rate = FEC_AUTO;
-        state->status = 0;
-        state->afc_loop = 0;
-        /* check if the demod is there */
-        if (tda80xx_writereg(state, 0x89, 0x00) < 0) goto error;
-        state->id = tda80xx_readreg(state, 0x00);
-        switch (state->id) {
-        case ID_TDA8044:
-                state->clk = 96000000;
-                printk("tda80xx: Detected tda8044\n");
-                break;
-        case ID_TDA8083:
-                state->clk = 64000000;
-                printk("tda80xx: Detected tda8083\n");
-                break;
-        default:
-                goto error;
-        }
-        /* setup IRQ */
-        if (state->config->irq) {
-                INIT_WORK(&state->worklet, tda80xx_worklet, state);
-                if ((ret = request_irq(state->config->irq, tda80xx_irq, SA_ONESHOT, "tda80xx", &state->worklet)) < 0) {
-                        printk(KERN_ERR "tda80xx: request_irq failed (%d)\n", ret);
-                        goto error;
-                }
-        }
-        /* create dvb_frontend */
-        state->frontend.ops = &state->ops;
-        state->frontend.demodulator_priv = state;
-        return &state->frontend;
-error:
-        kfree(state);
-        return NULL;
-}
-static struct dvb_frontend_ops tda80xx_ops = {
-        .info = {
-                .name = "Philips TDA80xx DVB-S",
-                .type = FE_QPSK,
-                .frequency_min = 500000,
-                .frequency_max = 2700000,
-                .frequency_stepsize = 125,
-                .symbol_rate_min = 4500000,
-                .symbol_rate_max = 45000000,
-                .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_QPSK |
-                        FE_CAN_MUTE_TS
-        },
-        .release = tda80xx_release,
-        .init = tda80xx_init,
-        .sleep = tda80xx_sleep,
-        .set_frontend = tda80xx_set_frontend,
-        .get_frontend = tda80xx_get_frontend,
-        .read_status = tda80xx_read_status,
-        .read_ber = tda80xx_read_ber,
-        .read_signal_strength = tda80xx_read_signal_strength,
-        .read_snr = tda80xx_read_snr,
-        .read_ucblocks = tda80xx_read_ucblocks,
-        .diseqc_send_master_cmd = tda80xx_send_diseqc_msg,
-        .diseqc_send_burst = tda80xx_send_diseqc_burst,
-        .set_tone = tda80xx_set_tone,
-        .set_voltage = tda80xx_set_voltage,
-};
-module_param(debug, int, 0644);
-MODULE_DESCRIPTION("Philips TDA8044 / TDA8083 DVB-S Demodulator driver");
-MODULE_AUTHOR("Felix Domke, Andreas Oberritter");
-MODULE_LICENSE("GPL");
-EXPORT_SYMBOL(tda80xx_attach);
diff --git a/drivers/media/dvb/frontends/tda80xx.h b/drivers/media/dvb/frontends/tda80xx.h
deleted file mode 100644
index cd639a0aad55..000000000000
--- a/drivers/media/dvb/frontends/tda80xx.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * tda80xx.c
- *
- * Philips TDA8044 / TDA8083 QPSK demodulator driver
- *
- * Copyright (C) 2001 Felix Domke <tmbinc@elitedvb.net>
- * Copyright (C) 2002-2004 Andreas Oberritter <obi@linuxtv.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#ifndef TDA80XX_H
-#define TDA80XX_H
-#include <linux/dvb/frontend.h>
-struct tda80xx_config
-{
-        /* the demodulator's i2c address */
-        u8 demod_address;
-        /* IRQ to use (0=>no IRQ used) */
-        u32 irq;
-        /* Register setting to use for 13v */
-        u8 volt13setting;
-        /* Register setting to use for 18v */
-        u8 volt18setting;
-        /* PLL maintenance */
-        int (*pll_init)(struct dvb_frontend* fe);
-        int (*pll_set)(struct dvb_frontend* fe, struct dvb_frontend_parameters* params);
-};
-extern struct dvb_frontend* tda80xx_attach(const struct tda80xx_config* config,
-                                           struct i2c_adapter* i2c);
-#endif // TDA80XX_H
diff --git a/drivers/media/dvb/ttpci/av7110.c b/drivers/media/dvb/ttpci/av7110.c
index 27494901975f..d36369e9e88f 100644
--- a/drivers/media/dvb/ttpci/av7110.c
+++ b/drivers/media/dvb/ttpci/av7110.c
@@ -2329,6 +2329,17 @@ static int frontend_init(struct av7110 *av7110)
                        av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
                        break;
+                case 0x0004: // Galaxis DVB-S rev1.3
+                        /* ALPS BSRV2 */
+                        av7110->fe = ves1x93_attach(&alps_bsrv2_config, &av7110->i2c_adap);
+                        if (av7110->fe) {
+                                av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
+                                av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
+                                av7110->fe->ops->set_tone = av7110_set_tone;
+                                av7110->recover = dvb_s_recover;
+                        }
+                        break;
                case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
                        /* Grundig 29504-451 */
                        av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap);
@@ -2930,6 +2941,7 @@ MAKE_AV7110_INFO(tts_1_3se,  "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
 MAKE_AV7110_INFO(ttt,        "Technotrend/Hauppauge DVB-T");
 MAKE_AV7110_INFO(fsc,        "Fujitsu Siemens DVB-C");
 MAKE_AV7110_INFO(fss,        "Fujitsu Siemens DVB-S rev1.6");
+MAKE_AV7110_INFO(gxs_1_3,    "Galaxis DVB-S rev1.3");
 static struct pci_device_id pci_tbl[] = {
        MAKE_EXTENSION_PCI(fsc,         0x110a, 0x0000),
@@ -2937,13 +2949,13 @@ static struct pci_device_id pci_tbl[] = {
        MAKE_EXTENSION_PCI(ttt_1_X,     0x13c2, 0x0001),
        MAKE_EXTENSION_PCI(ttc_2_X,     0x13c2, 0x0002),
        MAKE_EXTENSION_PCI(tts_2_X,     0x13c2, 0x0003),
+        MAKE_EXTENSION_PCI(gxs_1_3,     0x13c2, 0x0004),
        MAKE_EXTENSION_PCI(fss,         0x13c2, 0x0006),
        MAKE_EXTENSION_PCI(ttt,         0x13c2, 0x0008),
        MAKE_EXTENSION_PCI(ttc_1_X,     0x13c2, 0x000a),
        MAKE_EXTENSION_PCI(tts_2_3,     0x13c2, 0x000e),
        MAKE_EXTENSION_PCI(tts_1_3se,   0x13c2, 0x1002),
-/*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0004), UNDEFINED CARD */ // Galaxis DVB PC-Sat-Carte
 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
diff --git a/drivers/media/dvb/ttpci/av7110.h b/drivers/media/dvb/ttpci/av7110.h
index 6ea30df2e823..fafd25fab835 100644
--- a/drivers/media/dvb/ttpci/av7110.h
+++ b/drivers/media/dvb/ttpci/av7110.h
@@ -273,8 +273,6 @@ struct av7110 {
 extern int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
                       u16 subpid, u16 pcrpid);
-extern int av7110_setup_irc_config (struct av7110 *av7110, u32 ir_config);
 extern int av7110_ir_init(struct av7110 *av7110);
 extern void av7110_ir_exit(struct av7110 *av7110);
diff --git a/drivers/media/dvb/ttpci/av7110_ir.c b/drivers/media/dvb/ttpci/av7110_ir.c
index 9138132ad25f..617e4f6c0ed7 100644
--- a/drivers/media/dvb/ttpci/av7110_ir.c
+++ b/drivers/media/dvb/ttpci/av7110_ir.c
@@ -155,6 +155,19 @@ static void input_repeat_key(unsigned long data)
 }
+static int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
+{
+        int ret = 0;
+        dprintk(4, "%p\n", av7110);
+        if (av7110) {
+                ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
+                av7110->ir_config = ir_config;
+        }
+        return ret;
+}
 static int av7110_ir_write_proc(struct file *file, const char __user *buffer,
                                unsigned long count, void *data)
 {
@@ -187,19 +200,6 @@ static int av7110_ir_write_proc(struct file *file, const char __user *buffer,
 }
-int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
-{
-        int ret = 0;
-        dprintk(4, "%p\n", av7110);
-        if (av7110) {
-                ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
-                av7110->ir_config = ir_config;
-        }
-        return ret;
-}
 static void ir_handler(struct av7110 *av7110, u32 ircom)
 {
        dprintk(4, "ircommand = %08x\n", ircom);
diff --git a/drivers/media/video/bttv-driver.c b/drivers/media/video/bttv-driver.c
index aa4c4c521880..578b20085082 100644
--- a/drivers/media/video/bttv-driver.c
+++ b/drivers/media/video/bttv-driver.c
@@ -214,7 +214,7 @@ const struct bttv_tvnorm bttv_tvnorms[] = {
                   we can capture, of the first and second field. */
                .vbistart       = { 7,320 },
        },{
-                .v4l2_id        = V4L2_STD_NTSC_M,
+                .v4l2_id        = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
                .name           = "NTSC",
                .Fsc            = 28636363,
                .swidth         = 768,
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index c66c2c1f4809..08ffd1f325fc 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -220,33 +220,23 @@ static void input_change(struct i2c_client *client)
                cx25840_write(client, 0x808, 0xff);
                cx25840_write(client, 0x80b, 0x10);
        } else if (std & V4L2_STD_NTSC) {
-                /* NTSC */
+                /* Certain Hauppauge PVR150 models have a hardware bug
-                if (state->pvr150_workaround) {
+                   that causes audio to drop out. For these models the
-                        /* Certain Hauppauge PVR150 models have a hardware bug
+                   audio standard must be set explicitly.
-                           that causes audio to drop out. For these models the
+                   To be precise: it affects cards with tuner models
-                           audio standard must be set explicitly.
+                   85, 99 and 112 (model numbers from tveeprom). */
-                           To be precise: it affects cards with tuner models
+                int hw_fix = state->pvr150_workaround;
-                           85, 99 and 112 (model numbers from tveeprom). */
-                        if (std == V4L2_STD_NTSC_M_JP) {
+                if (std == V4L2_STD_NTSC_M_JP) {
-                                /* Japan uses EIAJ audio standard */
-                                cx25840_write(client, 0x808, 0x2f);
-                        } else {
-                                /* Others use the BTSC audio standard */
-                                cx25840_write(client, 0x808, 0x1f);
-                        }
-                        /* South Korea uses the A2-M (aka Zweiton M) audio
-                           standard, and should set 0x808 to 0x3f, but I don't
-                           know how to detect this. */
-                } else if (std == V4L2_STD_NTSC_M_JP) {
                        /* Japan uses EIAJ audio standard */
-                        cx25840_write(client, 0x808, 0xf7);
+                        cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
+                } else if (std == V4L2_STD_NTSC_M_KR) {
+                        /* South Korea uses A2 audio standard */
+                        cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
                } else {
                        /* Others use the BTSC audio standard */
-                        cx25840_write(client, 0x808, 0xf6);
+                        cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
                }
-                /* South Korea uses the A2-M (aka Zweiton M) audio standard,
-                   and should set 0x808 to 0xf8, but I don't know how to
-                   detect this. */
                cx25840_write(client, 0x80b, 0x00);
        }
@@ -330,17 +320,17 @@ static int set_v4lstd(struct i2c_client *client, v4l2_std_id std)
        u8 fmt=0;       /* zero is autodetect */
        /* First tests should be against specific std */
-        if (std & V4L2_STD_NTSC_M_JP) {
+        if (std == V4L2_STD_NTSC_M_JP) {
                fmt=0x2;
-        } else if (std & V4L2_STD_NTSC_443) {
+        } else if (std == V4L2_STD_NTSC_443) {
                fmt=0x3;
-        } else if (std & V4L2_STD_PAL_M) {
+        } else if (std == V4L2_STD_PAL_M) {
                fmt=0x5;
-        } else if (std & V4L2_STD_PAL_N) {
+        } else if (std == V4L2_STD_PAL_N) {
                fmt=0x6;
-        } else if (std & V4L2_STD_PAL_Nc) {
+        } else if (std == V4L2_STD_PAL_Nc) {
                fmt=0x7;
-        } else if (std & V4L2_STD_PAL_60) {
+        } else if (std == V4L2_STD_PAL_60) {
                fmt=0x8;
        } else {
                /* Then, test against generic ones */
@@ -369,7 +359,7 @@ v4l2_std_id cx25840_get_v4lstd(struct i2c_client * client)
        }
        switch (fmt) {
-        case 0x1: return V4L2_STD_NTSC_M;
+        case 0x1: return V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR;
        case 0x2: return V4L2_STD_NTSC_M_JP;
        case 0x3: return V4L2_STD_NTSC_443;
        case 0x4: return V4L2_STD_PAL;
diff --git a/drivers/media/video/cx88/Kconfig b/drivers/media/video/cx88/Kconfig
index 53308911ae6e..e99dfbbf3e95 100644
--- a/drivers/media/video/cx88/Kconfig
+++ b/drivers/media/video/cx88/Kconfig
@@ -32,6 +32,7 @@ config VIDEO_CX88_DVB
 config VIDEO_CX88_ALSA
        tristate "ALSA DMA audio support"
        depends on VIDEO_CX88 && SND && EXPERIMENTAL
+        select SND_PCM
        ---help---
          This is a video4linux driver for direct (DMA) audio on
          Conexant 2388x based TV cards.
@@ -48,6 +49,7 @@ config VIDEO_CX88_DVB_ALL_FRONTENDS
        default y
        depends on VIDEO_CX88_DVB
        select DVB_MT352
+        select VIDEO_CX88_VP3054
        select DVB_OR51132
        select DVB_CX22702
        select DVB_LGDT330X
@@ -69,6 +71,16 @@ config VIDEO_CX88_DVB_MT352
          This adds DVB-T support for cards based on the
          Connexant 2388x chip and the MT352 demodulator.
+config VIDEO_CX88_VP3054
+        tristate "VP-3054 Secondary I2C Bus Support"
+        default m
+        depends on DVB_MT352
+        ---help---
+          This adds DVB-T support for cards based on the
+          Connexant 2388x chip and the MT352 demodulator,
+          which also require support for the VP-3054
+          Secondary I2C bus, such at DNTV Live! DVB-T Pro.
 config VIDEO_CX88_DVB_OR51132
        bool "OR51132 ATSC Support"
        default y
diff --git a/drivers/media/video/cx88/Makefile b/drivers/media/video/cx88/Makefile
index 6e5eaa22619e..2b902784facc 100644
--- a/drivers/media/video/cx88/Makefile
+++ b/drivers/media/video/cx88/Makefile
@@ -4,8 +4,9 @@ cx8800-objs	:= cx88-video.o cx88-vbi.o
 cx8802-objs     := cx88-mpeg.o
 obj-$(CONFIG_VIDEO_CX88) += cx88xx.o cx8800.o cx8802.o cx88-blackbird.o
-obj-$(CONFIG_VIDEO_CX88_DVB) += cx88-dvb.o cx88-vp3054-i2c.o
+obj-$(CONFIG_VIDEO_CX88_DVB) += cx88-dvb.o
 obj-$(CONFIG_VIDEO_CX88_ALSA) += cx88-alsa.o
+obj-$(CONFIG_VIDEO_CX88_VP3054) += cx88-vp3054-i2c.o
 EXTRA_CFLAGS += -I$(src)/..
 EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/dvb-core
@@ -18,6 +19,6 @@ extra-cflags-$(CONFIG_DVB_LGDT330X)  += -DHAVE_LGDT330X=1
 extra-cflags-$(CONFIG_DVB_MT352)     += -DHAVE_MT352=1
 extra-cflags-$(CONFIG_DVB_NXT200X)   += -DHAVE_NXT200X=1
 extra-cflags-$(CONFIG_DVB_CX24123)   += -DHAVE_CX24123=1
-extra-cflags-$(CONFIG_VIDEO_CX88_DVB)+= -DHAVE_VP3054_I2C=1
+extra-cflags-$(CONFIG_VIDEO_CX88_VP3054)+= -DHAVE_VP3054_I2C=1
 EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m)
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c
index a2e36a1e5f59..2acccd6d49bc 100644
--- a/drivers/media/video/cx88/cx88-alsa.c
+++ b/drivers/media/video/cx88/cx88-alsa.c
@@ -128,7 +128,7 @@ MODULE_PARM_DESC(debug,"enable debug messages");
 * BOARD Specific: Sets audio DMA
 */
-int _cx88_start_audio_dma(snd_cx88_card_t *chip)
+static int _cx88_start_audio_dma(snd_cx88_card_t *chip)
 {
        struct cx88_buffer   *buf = chip->buf;
        struct cx88_core *core=chip->core;
@@ -173,7 +173,7 @@ int _cx88_start_audio_dma(snd_cx88_card_t *chip)
 /*
 * BOARD Specific: Resets audio DMA
 */
-int _cx88_stop_audio_dma(snd_cx88_card_t *chip)
+static int _cx88_stop_audio_dma(snd_cx88_card_t *chip)
 {
        struct cx88_core *core=chip->core;
        dprintk(1, "Stopping audio DMA\n");
@@ -613,7 +613,7 @@ static snd_kcontrol_new_t snd_cx88_capture_volume = {
 * Only boards with eeprom and byte 1 at eeprom=1 have it
 */
-struct pci_device_id cx88_audio_pci_tbl[] = {
+static struct pci_device_id cx88_audio_pci_tbl[] = {
        {0x14f1,0x8801,PCI_ANY_ID,PCI_ANY_ID,0,0,0},
        {0x14f1,0x8811,PCI_ANY_ID,PCI_ANY_ID,0,0,0},
        {0, }
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index ad2f565f522c..1bc999247fdc 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -1246,6 +1246,11 @@ struct cx88_subid cx88_subids[] = {
                .card      = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL,
        },{
                .subvendor = 0x18ac,
+                .subdevice = 0xdb54,
+                .card      = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL,
+                /* Re-branded DViCO: DigitalNow DVB-T Dual */
+        },{
+                .subvendor = 0x18ac,
                .subdevice = 0xdb11,
                .card      = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS,
                /* Re-branded DViCO: UltraView DVB-T Plus */
@@ -1293,6 +1298,7 @@ static void hauppauge_eeprom(struct cx88_core *core, u8 *eeprom_data)
        switch (tv.model)
        {
        case 28552: /* WinTV-PVR 'Roslyn' (No IR) */
+        case 34519: /* WinTV-PCI-FM */
        case 90002: /* Nova-T-PCI (9002) */
        case 92001: /* Nova-S-Plus (Video and IR) */
        case 92002: /* Nova-S-Plus (Video and IR) */
diff --git a/drivers/media/video/cx88/cx88-core.c b/drivers/media/video/cx88/cx88-core.c
index 8d6d6a6cf785..3720f24a25cf 100644
--- a/drivers/media/video/cx88/cx88-core.c
+++ b/drivers/media/video/cx88/cx88-core.c
@@ -787,12 +787,14 @@ static int set_pll(struct cx88_core *core, int prescale, u32 ofreq)
 int cx88_start_audio_dma(struct cx88_core *core)
 {
+        /* constant 128 made buzz in analog Nicam-stereo for bigger fifo_size */
+        int bpl = cx88_sram_channels[SRAM_CH25].fifo_size/4;
        /* setup fifo + format */
-        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], 128, 0);
+        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], bpl, 0);
-        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], 128, 0);
+        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], bpl, 0);
-        cx_write(MO_AUDD_LNGTH,    128); /* fifo bpl size */
+        cx_write(MO_AUDD_LNGTH, bpl); /* fifo bpl size */
-        cx_write(MO_AUDR_LNGTH,    128); /* fifo bpl size */
+        cx_write(MO_AUDR_LNGTH, bpl); /* fifo bpl size */
        /* start dma */
        cx_write(MO_AUD_DMACNTRL, 0x0003); /* Up and Down fifo enable */
diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c
index da2ad5c4b553..165d948624a3 100644
--- a/drivers/media/video/cx88/cx88-input.c
+++ b/drivers/media/video/cx88/cx88-input.c
@@ -482,6 +482,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
        switch (core->board) {
        case CX88_BOARD_DNTV_LIVE_DVB_T:
        case CX88_BOARD_KWORLD_DVB_T:
+        case CX88_BOARD_KWORLD_DVB_T_CX22702:
                ir_codes = ir_codes_dntv_live_dvb_t;
                ir->gpio_addr = MO_GP1_IO;
                ir->mask_keycode = 0x1f;
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index dff3893f32fd..e5ee8bceb210 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -139,6 +139,9 @@ int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
 {
        int ret, byte;
+        if (dev->state & DEV_DISCONNECTED)
+                return(-ENODEV);
        em28xx_regdbg("req=%02x, reg=%02x ", req, reg);
        ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
@@ -165,6 +168,9 @@ int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
        u8 val;
        int ret;
+        if (dev->state & DEV_DISCONNECTED)
+                return(-ENODEV);
        em28xx_regdbg("req=%02x, reg=%02x:", req, reg);
        ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
@@ -195,7 +201,12 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
        int ret;
        /*usb_control_msg seems to expect a kmalloced buffer */
-        unsigned char *bufs = kmalloc(len, GFP_KERNEL);
+        unsigned char *bufs;
+        if (dev->state & DEV_DISCONNECTED)
+                return(-ENODEV);
+        bufs = kmalloc(len, GFP_KERNEL);
        em28xx_regdbg("req=%02x reg=%02x:", req, reg);
@@ -212,7 +223,7 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
        ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req,
                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                              0x0000, reg, bufs, len, HZ);
-        mdelay(5);              /* FIXME: magic number */
+        msleep(5);              /* FIXME: magic number */
        kfree(bufs);
        return ret;
 }
@@ -253,7 +264,7 @@ int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 * val)
        if ((ret = em28xx_read_reg(dev, AC97BUSY_REG)) < 0)
                return ret;
        else if (((u8) ret) & 0x01) {
-                em28xx_warn ("AC97 command still being exectuted: not handled properly!\n");
+                em28xx_warn ("AC97 command still being executed: not handled properly!\n");
        }
        return 0;
 }
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
index 0591a705b7a1..6ca8631bc36d 100644
--- a/drivers/media/video/em28xx/em28xx-i2c.c
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -78,7 +78,7 @@ static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
                ret = dev->em28xx_read_reg(dev, 0x05);
                if (ret == 0x80 + len - 1)
                        return len;
-                mdelay(5);
+                msleep(5);
        }
        em28xx_warn("i2c write timed out\n");
        return -EIO;
@@ -138,7 +138,7 @@ static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
                        return -ENODEV;
                else if (msg == 0x84)
                        return 0;
-                mdelay(5);
+                msleep(5);
        }
        return -ENODEV;
 }
@@ -278,9 +278,9 @@ static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
                                                           msgs[i].buf,
                                                           msgs[i].len,
                                                           i == num - 1);
-                        if (rc < 0)
-                                goto err;
                }
+                if (rc < 0)
+                        goto err;
                if (i2c_debug>=2)
                        printk("\n");
        }
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index eea304f75176..94a14a2bb6d6 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -6,6 +6,9 @@
                      Mauro Carvalho Chehab <mchehab@brturbo.com.br>
                      Sascha Sommer <saschasommer@freenet.de>
+        Some parts based on SN9C10x PC Camera Controllers GPL driver made
+                by Luca Risolia <luca.risolia@studio.unibo.it>
   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
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index c64718aec9cb..5a35d3b6550d 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -136,7 +136,7 @@ struct saa7134_board saa7134_boards[] = {
        },
        [SAA7134_BOARD_FLYVIDEO2000] = {
                /* "TC Wan" <tcwan@cs.usm.my> */
-                .name           = "LifeView FlyVIDEO2000",
+                .name           = "LifeView/Typhoon FlyVIDEO2000",
                .audio_clock    = 0x00200000,
                .tuner_type     = TUNER_LG_PAL_NEW_TAPC,
                .radio_type     = UNSET,
@@ -1884,44 +1884,38 @@ struct saa7134_board saa7134_boards[] = {
                        .gpio = 0x000,
                },
        },
-        [SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS] = {
+        [SAA7134_BOARD_FLYDVBT_DUO_CARDBUS] = {
-                .name           = "Typhoon DVB-T Duo Digital/Analog Cardbus",
+                .name           = "LifeView/Typhoon FlyDVB-T Duo Cardbus",
                .audio_clock    = 0x00200000,
                .tuner_type     = TUNER_PHILIPS_TDA8290,
                .radio_type     = UNSET,
                .tuner_addr     = ADDR_UNSET,
                .radio_addr     = ADDR_UNSET,
                .mpeg           = SAA7134_MPEG_DVB,
-                /* .gpiomask       = 0xe000, */
+                .gpiomask       = 0x00200000,
                .inputs         = {{
                        .name = name_tv,
                        .vmux = 1,
                        .amux = TV,
-                /*      .gpio = 0x0000,      */
+                        .gpio = 0x200000,       /* GPIO21=High for TV input */
                        .tv   = 1,
                },{
+                        .name = name_svideo,    /* S-Video signal on S-Video input */
+                        .vmux = 8,
+                        .amux = LINE2,
+                },{
                        .name = name_comp1,     /* Composite signal on S-Video input */
                        .vmux = 0,
                        .amux = LINE2,
-                /*      .gpio = 0x4000,      */
                },{
                        .name = name_comp2,     /* Composite input */
                        .vmux = 3,
                        .amux = LINE2,
-                /*      .gpio = 0x4000,      */
-                },{
-                        .name = name_svideo,    /* S-Video signal on S-Video input */
-                        .vmux = 8,
-                        .amux = LINE2,
-                /*      .gpio = 0x4000,      */
                }},
                .radio = {
                        .name = name_radio,
-                        .amux = LINE2,
+                        .amux = TV,
-                },
+                        .gpio = 0x000000,       /* GPIO21=Low for FM radio antenna */
-                .mute = {
-                        .name = name_mute,
-                        .amux = LINE1,
                },
        },
        [SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII] = {
@@ -2701,6 +2695,12 @@ struct pci_device_id saa7134_pci_tbl[] = {
                .driver_data  = SAA7134_BOARD_FLYVIDEO2000,
        },{
                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
+                .subvendor    = 0x4e42,         /* Typhoon */
+                .subdevice    = 0x0138,         /* LifeView FlyTV Prime30 OEM */
+                .driver_data  = SAA7134_BOARD_FLYVIDEO2000,
+        },{
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
                .subvendor    = 0x5168,
                .subdevice    = 0x0212, /* minipci, LR212 */
@@ -2935,7 +2935,7 @@ struct pci_device_id saa7134_pci_tbl[] = {
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
                .subvendor    = 0x5168,
                .subdevice    = 0x0502,                /* Cardbus version */
-                .driver_data  = SAA7134_BOARD_FLYDVBTDUO,
+                .driver_data  = SAA7134_BOARD_FLYDVBT_DUO_CARDBUS,
        },{
                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
@@ -2980,12 +2980,12 @@ struct pci_device_id saa7134_pci_tbl[] = {
                .subdevice    = 0x1370,        /* cardbus version */
                .driver_data  = SAA7134_BOARD_ADS_INSTANT_TV,
-        },{     /* Typhoon DVB-T Duo Digital/Analog Cardbus */
+        },{
                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
-                .subvendor    = 0x4e42,
+                .subvendor    = 0x4e42,         /* Typhoon */
-                .subdevice    = 0x0502,
+                .subdevice    = 0x0502,         /* LifeView LR502 OEM */
-                .driver_data  = SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS,
+                .driver_data  = SAA7134_BOARD_FLYDVBT_DUO_CARDBUS,
        },{
                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
@@ -3206,8 +3206,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
                saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x00040000, 0x00040000);
                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00040000, 0x00000004);
                break;
-        case SAA7134_BOARD_FLYDVBTDUO:
+        case SAA7134_BOARD_FLYDVBT_DUO_CARDBUS:
-        case SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS:
                /* turn the fan on */
                saa_writeb(SAA7134_GPIO_GPMODE3, 0x08);
                saa_writeb(SAA7134_GPIO_GPSTATUS3, 0x06);
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c
index 399f9952596c..1a536e865277 100644
--- a/drivers/media/video/saa7134/saa7134-dvb.c
+++ b/drivers/media/video/saa7134/saa7134-dvb.c
@@ -861,7 +861,7 @@ static int dvb_init(struct saa7134_dev *dev)
                dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config,
                                                    &dev->i2c_adap);
                break;
-        case SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS:
+        case SAA7134_BOARD_FLYDVBT_DUO_CARDBUS:
                dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config,
                                                    &dev->i2c_adap);
                break;
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index e70eae8d29bb..3261d8bebdd1 100644
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -185,7 +185,7 @@ struct saa7134_format {
 #define SAA7134_BOARD_AVERMEDIA_GO_007_FM 57
 #define SAA7134_BOARD_ADS_INSTANT_TV 58
 #define SAA7134_BOARD_KWORLD_VSTREAM_XPERT 59
-#define SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS 60
+#define SAA7134_BOARD_FLYDVBT_DUO_CARDBUS 60
 #define SAA7134_BOARD_PHILIPS_TOUGH 61
 #define SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII 62
 #define SAA7134_BOARD_KWORLD_XPERT 63
diff --git a/drivers/media/video/stradis.c b/drivers/media/video/stradis.c
index 54fc33011ffb..9d769264a329 100644
--- a/drivers/media/video/stradis.c
+++ b/drivers/media/video/stradis.c
@@ -2012,7 +2012,6 @@ static int __devinit init_saa7146(struct pci_dev *pdev)
 {
        struct saa7146 *saa = pci_get_drvdata(pdev);
-        memset(saa, 0, sizeof(*saa));
        saa->user = 0;
        /* reset the saa7146 */
        saawrite(0xffff0000, SAA7146_MC1);
@@ -2062,16 +2061,16 @@ static int __devinit init_saa7146(struct pci_dev *pdev)
        }
        if (saa->audbuf == NULL && (saa->audbuf = vmalloc(65536)) == NULL) {
                dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr);
-                goto errvid;
+                goto errfree;
        }
        if (saa->osdbuf == NULL && (saa->osdbuf = vmalloc(131072)) == NULL) {
                dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr);
-                goto erraud;
+                goto errfree;
        }
        /* allocate 81920 byte buffer for clipping */
        if ((saa->dmavid2 = kzalloc(VIDEO_CLIPMAP_SIZE, GFP_KERNEL)) == NULL) {
                dev_err(&pdev->dev, "%d: clip kmalloc failed\n", saa->nr);
-                goto errosd;
+                goto errfree;
        }
        /* setup clipping registers */
        saawrite(virt_to_bus(saa->dmavid2), SAA7146_BASE_EVEN2);
@@ -2085,15 +2084,11 @@ static int __devinit init_saa7146(struct pci_dev *pdev)
        I2CBusScan(saa);
        return 0;
-errosd:
+errfree:
        vfree(saa->osdbuf);
-        saa->osdbuf = NULL;
-erraud:
        vfree(saa->audbuf);
-        saa->audbuf = NULL;
-errvid:
        vfree(saa->vidbuf);
-        saa->vidbuf = NULL;
+        saa->audbuf = saa->osdbuf = saa->vidbuf = NULL;
 err:
        return -ENOMEM;
 }
diff --git a/drivers/media/video/tda9887.c b/drivers/media/video/tda9887.c
index 5815649bdc78..0d54f6c1982b 100644
--- a/drivers/media/video/tda9887.c
+++ b/drivers/media/video/tda9887.c
@@ -231,7 +231,7 @@ static struct tvnorm tvnorms[] = {
                           cAudioIF_6_5   |
                           cVideoIF_38_90 ),
        },{
-                .std   = V4L2_STD_NTSC_M,
+                .std   = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
                .name  = "NTSC-M",
                .b     = ( cNegativeFmTV  |
                           cQSS           ),
@@ -619,6 +619,11 @@ static int tda9887_fixup_std(struct tda9887 *t)
                        tda9887_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
                        t->std = V4L2_STD_NTSC_M_JP;
                        break;
+                case 'k':
+                case 'K':
+                        tda9887_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
+                        t->std = V4L2_STD_NTSC_M_KR;
+                        break;
                case '-':
                        /* default parameter, do nothing */
                        break;
@@ -876,7 +881,7 @@ static int tda9887_resume(struct device * dev)
 /* ----------------------------------------------------------------------- */
 static struct i2c_driver driver = {
-        .id             = -1, /* FIXME */
+        .id             = I2C_DRIVERID_TDA9887,
        .attach_adapter = tda9887_probe,
        .detach_client  = tda9887_detach,
        .command        = tda9887_command,
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 2995b22acb43..e7ee619d62c5 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -216,6 +216,7 @@ static void set_type(struct i2c_client *c, unsigned int type,
                buffer[3] = 0xa4;
                i2c_master_send(c,buffer,4);
                default_tuner_init(c);
+                break;
        default:
                default_tuner_init(c);
                break;
@@ -365,6 +366,11 @@ static int tuner_fixup_std(struct tuner *t)
                        tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
                        t->std = V4L2_STD_NTSC_M_JP;
                        break;
+                case 'k':
+                case 'K':
+                        tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
+                        t->std = V4L2_STD_NTSC_M_KR;
+                        break;
                case '-':
                        /* default parameter, do nothing */
                        break;
@@ -448,7 +454,7 @@ static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
                        printk("%02x ",buffer[i]);
                printk("\n");
        }
-        /* TEA5767 autodetection code - only for addr = 0xc0 */
+        /* autodetection code based on the i2c addr */
        if (!no_autodetect) {
                switch (addr) {
                case 0x42:
diff --git a/drivers/media/video/tvaudio.c b/drivers/media/video/tvaudio.c
index 6d03b9b05c6e..c8e5ad0e8185 100644
--- a/drivers/media/video/tvaudio.c
+++ b/drivers/media/video/tvaudio.c
@@ -390,6 +390,14 @@ static void tda9840_setmode(struct CHIPSTATE *chip, int mode)
                chip_write(chip, TDA9840_SW, t);
 }
+static int tda9840_checkit(struct CHIPSTATE *chip)
+{
+        int rc;
+        rc = chip_read(chip);
+        /* lower 5 bits should be 0 */
+        return ((rc & 0x1f) == 0) ? 1 : 0;
+}
 /* ---------------------------------------------------------------------- */
 /* audio chip descriptions - defines+functions for tda985x                */
@@ -1264,6 +1272,7 @@ static struct CHIPDESC chiplist[] = {
                .addr_hi    = I2C_TDA9840 >> 1,
                .registers  = 5,
+                .checkit    = tda9840_checkit,
                .getmode    = tda9840_getmode,
                .setmode    = tda9840_setmode,
                .checkmode  = generic_checkmode,
diff --git a/drivers/media/video/tvp5150.c b/drivers/media/video/tvp5150.c
index fad9ea0ae4f2..1864423b3046 100644
--- a/drivers/media/video/tvp5150.c
+++ b/drivers/media/video/tvp5150.c
@@ -746,24 +746,27 @@ static int tvp5150_set_std(struct i2c_client *c, v4l2_std_id std)
 static inline void tvp5150_reset(struct i2c_client *c)
 {
-        u8 type, ver_656, msb_id, lsb_id, msb_rom, lsb_rom;
+        u8 msb_id, lsb_id, msb_rom, lsb_rom;
        struct tvp5150 *decoder = i2c_get_clientdata(c);
-        type=tvp5150_read(c,TVP5150_AUTOSW_MSK);
        msb_id=tvp5150_read(c,TVP5150_MSB_DEV_ID);
        lsb_id=tvp5150_read(c,TVP5150_LSB_DEV_ID);
        msb_rom=tvp5150_read(c,TVP5150_ROM_MAJOR_VER);
        lsb_rom=tvp5150_read(c,TVP5150_ROM_MINOR_VER);
-        if (type==0xdc) {
+        if ((msb_rom==4)&&(lsb_rom==0)) { /* Is TVP5150AM1 */
-                ver_656=tvp5150_read(c,TVP5150_REV_SELECT);
+                tvp5150_info("tvp%02x%02xam1 detected.\n",msb_id, lsb_id);
-                tvp5150_info("tvp%02x%02xam1 detected 656 version is %d.\n",msb_id, lsb_id,ver_656);
-        } else if (type==0xfc) {
+                /* ITU-T BT.656.4 timing */
-                tvp5150_info("tvp%02x%02xa detected.\n",msb_id, lsb_id);
+                tvp5150_write(c,TVP5150_REV_SELECT,0);
        } else {
-                tvp5150_info("unknown tvp%02x%02x chip detected(%d).\n",msb_id,lsb_id,type);
+                if ((msb_rom==3)||(lsb_rom==0x21)) { /* Is TVP5150A */
+                        tvp5150_info("tvp%02x%02xa detected.\n",msb_id, lsb_id);
+                } else {
+                        tvp5150_info("*** unknown tvp%02x%02x chip detected.\n",msb_id,lsb_id);
+                        tvp5150_info("*** Rom ver is %d.%d\n",msb_rom,lsb_rom);
+                }
        }
-        tvp5150_info("Rom ver is %d.%d\n",msb_rom,lsb_rom);
        /* Initializes TVP5150 to its default values */
        tvp5150_write_inittab(c, tvp5150_init_default);
@@ -893,6 +896,17 @@ static int tvp5150_command(struct i2c_client *c,
                }
        case DECODER_GET_STATUS:
                {
+                        int *iarg = arg;
+                        int status;
+                        int res=0;
+                        status = tvp5150_read(c, 0x88);
+                        if(status&0x08){
+                                res |= DECODER_STATUS_COLOR;
+                        }
+                        if(status&0x04 && status&0x02){
+                                res |= DECODER_STATUS_GOOD;
+                        }
+                        *iarg=res;
                        break;
                }
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index adfba44dac5a..2beac55b57d6 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -586,6 +586,7 @@ struct rtl8139_private {
        dma_addr_t tx_bufs_dma;
        signed char phys[4];            /* MII device addresses. */
        char twistie, twist_row, twist_col;     /* Twister tune state. */
+        unsigned int watchdog_fired : 1;
        unsigned int default_port : 4;  /* Last dev->if_port value. */
        unsigned int have_thread : 1;
        spinlock_t lock;
@@ -638,6 +639,7 @@ static void rtl8139_set_rx_mode (struct net_device *dev);
 static void __set_rx_mode (struct net_device *dev);
 static void rtl8139_hw_start (struct net_device *dev);
 static void rtl8139_thread (void *_data);
+static void rtl8139_tx_timeout_task(void *_data);
 static struct ethtool_ops rtl8139_ethtool_ops;
 /* write MMIO register, with flush */
@@ -1598,13 +1600,14 @@ static void rtl8139_thread (void *_data)
 {
        struct net_device *dev = _data;
        struct rtl8139_private *tp = netdev_priv(dev);
-        unsigned long thr_delay;
+        unsigned long thr_delay = next_tick;
-        if (rtnl_shlock_nowait() == 0) {
+        if (tp->watchdog_fired) {
+                tp->watchdog_fired = 0;
+                rtl8139_tx_timeout_task(_data);
+        } else if (rtnl_shlock_nowait() == 0) {
                rtl8139_thread_iter (dev, tp, tp->mmio_addr);
                rtnl_unlock ();
-                thr_delay = next_tick;
        } else {
                /* unlikely race.  mitigate with fast poll. */
                thr_delay = HZ / 2;
@@ -1631,7 +1634,8 @@ static void rtl8139_stop_thread(struct rtl8139_private *tp)
        if (tp->have_thread) {
                cancel_rearming_delayed_work(&tp->thread);
                tp->have_thread = 0;
-        }
+        } else
+                flush_scheduled_work();
 }
 static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
@@ -1642,14 +1646,13 @@ static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
        /* XXX account for unsent Tx packets in tp->stats.tx_dropped */
 }
+static void rtl8139_tx_timeout_task (void *_data)
-static void rtl8139_tx_timeout (struct net_device *dev)
 {
+        struct net_device *dev = _data;
        struct rtl8139_private *tp = netdev_priv(dev);
        void __iomem *ioaddr = tp->mmio_addr;
        int i;
        u8 tmp8;
-        unsigned long flags;
        printk (KERN_DEBUG "%s: Transmit timeout, status %2.2x %4.4x %4.4x "
                "media %2.2x.\n", dev->name, RTL_R8 (ChipCmd),
@@ -1670,23 +1673,34 @@ static void rtl8139_tx_timeout (struct net_device *dev)
        if (tmp8 & CmdTxEnb)
                RTL_W8 (ChipCmd, CmdRxEnb);
-        spin_lock(&tp->rx_lock);
+        spin_lock_bh(&tp->rx_lock);
        /* Disable interrupts by clearing the interrupt mask. */
        RTL_W16 (IntrMask, 0x0000);
        /* Stop a shared interrupt from scavenging while we are. */
-        spin_lock_irqsave (&tp->lock, flags);
+        spin_lock_irq(&tp->lock);
        rtl8139_tx_clear (tp);
-        spin_unlock_irqrestore (&tp->lock, flags);
+        spin_unlock_irq(&tp->lock);
        /* ...and finally, reset everything */
        if (netif_running(dev)) {
                rtl8139_hw_start (dev);
                netif_wake_queue (dev);
        }
-        spin_unlock(&tp->rx_lock);
+        spin_unlock_bh(&tp->rx_lock);
 }
+static void rtl8139_tx_timeout (struct net_device *dev)
+{
+        struct rtl8139_private *tp = netdev_priv(dev);
+        if (!tp->have_thread) {
+                INIT_WORK(&tp->thread, rtl8139_tx_timeout_task, dev);
+                schedule_delayed_work(&tp->thread, next_tick);
+        } else
+                tp->watchdog_fired = 1;
+}
 static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev)
 {
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 6a6a08441804..47c72a63dfe1 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -4,9 +4,9 @@
 #
 menu "Network device support"
+        depends on NET
 config NETDEVICES
-        depends on NET
        default y if UML
        bool "Network device support"
        ---help---
@@ -24,9 +24,6 @@ config NETDEVICES
          If unsure, say Y.
-# All the following symbols are dependent on NETDEVICES - do not repeat
-# that for each of the symbols.
-if NETDEVICES
 config IFB
        tristate "Intermediate Functional Block support"
@@ -2718,8 +2715,6 @@ config NETCONSOLE
        If you want to log kernel messages over the network, enable this.
        See <file:Documentation/networking/netconsole.txt> for details.
-endif #NETDEVICES
 config NETPOLL
        def_bool NETCONSOLE
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 4ff006c37626..e0f51afec778 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -1145,7 +1145,8 @@ int bond_sethwaddr(struct net_device *bond_dev, struct net_device *slave_dev)
 }
 #define BOND_INTERSECT_FEATURES \
-        (NETIF_F_SG|NETIF_F_IP_CSUM|NETIF_F_NO_CSUM|NETIF_F_HW_CSUM)
+        (NETIF_F_SG|NETIF_F_IP_CSUM|NETIF_F_NO_CSUM|NETIF_F_HW_CSUM|\
+        NETIF_F_TSO|NETIF_F_UFO)
 /* 
 * Compute the common dev->feature set available to all slaves.  Some
@@ -1168,6 +1169,16 @@ static int bond_compute_features(struct bonding *bond)
                          NETIF_F_HW_CSUM)))
                features &= ~NETIF_F_SG;
+        /* 
+         * features will include NETIF_F_TSO (NETIF_F_UFO) iff all 
+         * slave devices support NETIF_F_TSO (NETIF_F_UFO), which 
+         * implies that all slaves also support scatter-gather 
+         * (NETIF_F_SG), which implies that features also includes 
+         * NETIF_F_SG. So no need to check whether we have an  
+         * illegal combination of NETIF_F_{TSO,UFO} and 
+         * !NETIF_F_SG 
+         */
        features |= (bond_dev->features & ~BOND_INTERSECT_FEATURES);
        bond_dev->features = features;
@@ -4080,6 +4091,8 @@ static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
 static struct ethtool_ops bond_ethtool_ops = {
        .get_tx_csum            = ethtool_op_get_tx_csum,
+        .get_tso                = ethtool_op_get_tso,
+        .get_ufo                = ethtool_op_get_ufo,
        .get_sg                 = ethtool_op_get_sg,
        .get_drvinfo            = bond_ethtool_get_drvinfo,
 };
diff --git a/drivers/net/bonding/bond_sysfs.c b/drivers/net/bonding/bond_sysfs.c
index 32d13da43a0b..041bcc583557 100644
--- a/drivers/net/bonding/bond_sysfs.c
+++ b/drivers/net/bonding/bond_sysfs.c
@@ -260,7 +260,7 @@ static ssize_t bonding_store_slaves(struct class_device *cd, const char *buffer,
        char *ifname;
        int i, res, found, ret = count;
        struct slave *slave;
-        struct net_device *dev = 0;
+        struct net_device *dev = NULL;
        struct bonding *bond = to_bond(cd);
        /* Quick sanity check -- is the bond interface up? */
@@ -995,7 +995,7 @@ static ssize_t bonding_store_primary(struct class_device *cd, const char *buf, s
                        printk(KERN_INFO DRV_NAME
                               ": %s: Setting primary slave to None.\n",
                               bond->dev->name);
-                        bond->primary_slave = 0;
+                        bond->primary_slave = NULL;
                                bond_select_active_slave(bond);
                } else {
                        printk(KERN_INFO DRV_NAME
@@ -1123,7 +1123,7 @@ static ssize_t bonding_store_active_slave(struct class_device *cd, const char *b
                        printk(KERN_INFO DRV_NAME
                               ": %s: Setting active slave to None.\n",
                               bond->dev->name);
-                        bond->primary_slave = 0;
+                        bond->primary_slave = NULL;
                                bond_select_active_slave(bond);
                } else {
                        printk(KERN_INFO DRV_NAME
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index bf1fd2b98bf8..24253c807e55 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -2752,8 +2752,6 @@ static int e100_resume(struct pci_dev *pdev)
        retval = pci_enable_wake(pdev, 0, 0);
        if (retval)
                DPRINTK(PROBE,ERR, "Error clearing wake events\n");
-        if(e100_hw_init(nic))
-                DPRINTK(HW, ERR, "e100_hw_init failed\n");
        netif_device_attach(netdev);
        if(netif_running(netdev))
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 0c18dbd67d3b..0e8e3fcde9ff 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -199,8 +199,7 @@ static int gfar_probe(struct platform_device *pdev)
        /* get a pointer to the register memory */
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        priv->regs = (struct gfar *)
+        priv->regs = ioremap(r->start, sizeof (struct gfar));
-                ioremap(r->start, sizeof (struct gfar));
        if (NULL == priv->regs) {
                err = -ENOMEM;
@@ -369,7 +368,7 @@ static int gfar_probe(struct platform_device *pdev)
        return 0;
 register_fail:
-        iounmap((void *) priv->regs);
+        iounmap(priv->regs);
 regs_fail:
        free_netdev(dev);
        return err;
@@ -382,7 +381,7 @@ static int gfar_remove(struct platform_device *pdev)
        platform_set_drvdata(pdev, NULL);
-        iounmap((void *) priv->regs);
+        iounmap(priv->regs);
        free_netdev(dev);
        return 0;
@@ -454,8 +453,7 @@ static void init_registers(struct net_device *dev)
        /* Zero out the rmon mib registers if it has them */
        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
-                memset((void *) &(priv->regs->rmon), 0,
+                memset_io(&(priv->regs->rmon), 0, sizeof (struct rmon_mib));
-                       sizeof (struct rmon_mib));
                /* Mask off the CAM interrupts */
                gfar_write(&priv->regs->rmon.cam1, 0xffffffff);
@@ -477,7 +475,7 @@ static void init_registers(struct net_device *dev)
 void gfar_halt(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
        u32 tempval;
        /* Mask all interrupts */
@@ -507,7 +505,7 @@ void gfar_halt(struct net_device *dev)
 void stop_gfar(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
        unsigned long flags;
        phy_stop(priv->phydev);
@@ -590,7 +588,7 @@ static void free_skb_resources(struct gfar_private *priv)
 void gfar_start(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
        u32 tempval;
        /* Enable Rx and Tx in MACCFG1 */
@@ -624,7 +622,7 @@ int startup_gfar(struct net_device *dev)
        unsigned long vaddr;
        int i;
        struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
        int err = 0;
        u32 rctrl = 0;
        u32 attrs = 0;
@@ -1622,7 +1620,7 @@ static irqreturn_t gfar_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 static void adjust_link(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
        unsigned long flags;
        struct phy_device *phydev = priv->phydev;
        int new_state = 0;
@@ -1703,7 +1701,7 @@ static void gfar_set_multi(struct net_device *dev)
 {
        struct dev_mc_list *mc_ptr;
        struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
        u32 tempval;
        if(dev->flags & IFF_PROMISC) {
@@ -1842,7 +1840,7 @@ static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr)
        int idx;
        char tmpbuf[MAC_ADDR_LEN];
        u32 tempval;
-        u32 *macptr = &priv->regs->macstnaddr1;
+        u32 __iomem *macptr = &priv->regs->macstnaddr1;
        macptr += num*2;
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index cb9d66ac3ab9..d37d5401be6e 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -682,8 +682,8 @@ struct gfar_private {
        struct rxbd8 *cur_rx;           /* Next free rx ring entry */
        struct txbd8 *cur_tx;           /* Next free ring entry */
        struct txbd8 *dirty_tx;         /* The Ring entry to be freed. */
-        struct gfar *regs;      /* Pointer to the GFAR memory mapped Registers */
+        struct gfar __iomem *regs;      /* Pointer to the GFAR memory mapped Registers */
-        u32 *hash_regs[16];
+        u32 __iomem *hash_regs[16];
        int hash_width;
        struct net_device_stats stats; /* linux network statistics */
        struct gfar_extra_stats extra_stats;
@@ -718,14 +718,14 @@ struct gfar_private {
        uint32_t msg_enable;
 };
-static inline u32 gfar_read(volatile unsigned *addr)
+static inline u32 gfar_read(volatile unsigned __iomem *addr)
 {
        u32 val;
        val = in_be32(addr);
        return val;
 }
-static inline void gfar_write(volatile unsigned *addr, u32 val)
+static inline void gfar_write(volatile unsigned __iomem *addr, u32 val)
 {
        out_be32(addr, val);
 }
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 765e810620fe..5de7b2e259dc 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -144,11 +144,11 @@ static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy,
        u64 *extra = (u64 *) & priv->extra_stats;
        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
-                u32 *rmon = (u32 *) & priv->regs->rmon;
+                u32 __iomem *rmon = (u32 __iomem *) & priv->regs->rmon;
                struct gfar_stats *stats = (struct gfar_stats *) buf;
                for (i = 0; i < GFAR_RMON_LEN; i++)
-                        stats->rmon[i] = (u64) (rmon[i]);
+                        stats->rmon[i] = (u64) gfar_read(&rmon[i]);
                for (i = 0; i < GFAR_EXTRA_STATS_LEN; i++)
                        stats->extra[i] = extra[i];
@@ -221,11 +221,11 @@ static void gfar_get_regs(struct net_device *dev, struct ethtool_regs *regs, voi
 {
        int i;
        struct gfar_private *priv = netdev_priv(dev);
-        u32 *theregs = (u32 *) priv->regs;
+        u32 __iomem *theregs = (u32 __iomem *) priv->regs;
        u32 *buf = (u32 *) regbuf;
        for (i = 0; i < sizeof (struct gfar) / sizeof (u32); i++)
-                buf[i] = theregs[i];
+                buf[i] = gfar_read(&theregs[i]);
 }
 /* Convert microseconds to ethernet clock ticks, which changes
diff --git a/drivers/net/gianfar_mii.c b/drivers/net/gianfar_mii.c
index 74e52fcbf806..c6b725529af5 100644
--- a/drivers/net/gianfar_mii.c
+++ b/drivers/net/gianfar_mii.c
@@ -50,7 +50,7 @@
 * All PHY configuration is done through the TSEC1 MIIM regs */
 int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
 {
-        struct gfar_mii *regs = bus->priv;
+        struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
        /* Set the PHY address and the register address we want to write */
        gfar_write(&regs->miimadd, (mii_id << 8) | regnum);
@@ -70,7 +70,7 @@ int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
 * configuration has to be done through the TSEC1 MIIM regs */
 int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
 {
-        struct gfar_mii *regs = bus->priv;
+        struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
        u16 value;
        /* Set the PHY address and the register address we want to read */
@@ -94,7 +94,7 @@ int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
 /* Reset the MIIM registers, and wait for the bus to free */
 int gfar_mdio_reset(struct mii_bus *bus)
 {
-        struct gfar_mii *regs = bus->priv;
+        struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
        unsigned int timeout = PHY_INIT_TIMEOUT;
        spin_lock_bh(&bus->mdio_lock);
@@ -126,7 +126,7 @@ int gfar_mdio_probe(struct device *dev)
 {
        struct platform_device *pdev = to_platform_device(dev);
        struct gianfar_mdio_data *pdata;
-        struct gfar_mii *regs;
+        struct gfar_mii __iomem *regs;
        struct mii_bus *new_bus;
        struct resource *r;
        int err = 0;
@@ -155,15 +155,14 @@ int gfar_mdio_probe(struct device *dev)
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        /* Set the PHY base address */
-        regs = (struct gfar_mii *) ioremap(r->start,
+        regs = ioremap(r->start, sizeof (struct gfar_mii));
-                        sizeof (struct gfar_mii));
        if (NULL == regs) {
                err = -ENOMEM;
                goto reg_map_fail;
        }
-        new_bus->priv = regs;
+        new_bus->priv = (void __force *)regs;
        new_bus->irq = pdata->irq;
@@ -181,7 +180,7 @@ int gfar_mdio_probe(struct device *dev)
        return 0;
 bus_register_fail:
-        iounmap((void *) regs);
+        iounmap(regs);
 reg_map_fail:
        kfree(new_bus);
@@ -197,7 +196,7 @@ int gfar_mdio_remove(struct device *dev)
        dev_set_drvdata(dev, NULL);
-        iounmap((void *) (&bus->priv));
+        iounmap((void __iomem *)bus->priv);
        bus->priv = NULL;
        kfree(bus);
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 2e1bed153c39..6e1018448eea 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -484,13 +484,12 @@ static void mdio_write(void __iomem *ioaddr, int RegAddr, int value)
        int i;
        RTL_W32(PHYAR, 0x80000000 | (RegAddr & 0xFF) << 16 | value);
-        udelay(1000);
-        for (i = 2000; i > 0; i--) {
+        for (i = 20; i > 0; i--) {
                /* Check if the RTL8169 has completed writing to the specified MII register */
                if (!(RTL_R32(PHYAR) & 0x80000000)) 
                        break;
-                udelay(100);
+                udelay(25);
        }
 }
@@ -499,15 +498,14 @@ static int mdio_read(void __iomem *ioaddr, int RegAddr)
        int i, value = -1;
        RTL_W32(PHYAR, 0x0 | (RegAddr & 0xFF) << 16);
-        udelay(1000);
-        for (i = 2000; i > 0; i--) {
+        for (i = 20; i > 0; i--) {
                /* Check if the RTL8169 has completed retrieving data from the specified MII register */
                if (RTL_R32(PHYAR) & 0x80000000) {
                        value = (int) (RTL_R32(PHYAR) & 0xFFFF);
                        break;
                }
-                udelay(100);
+                udelay(25);
        }
        return value;
 }
@@ -677,6 +675,9 @@ static int rtl8169_set_speed_xmii(struct net_device *dev,
                if (duplex == DUPLEX_HALF)
                        auto_nego &= ~(PHY_Cap_10_Full | PHY_Cap_100_Full);
+                if (duplex == DUPLEX_FULL)
+                        auto_nego &= ~(PHY_Cap_10_Half | PHY_Cap_100_Half);
        }
        tp->phy_auto_nego_reg = auto_nego;
diff --git a/drivers/net/sis900.h b/drivers/net/sis900.h
index 4233ea55670f..50323941e3c0 100644
--- a/drivers/net/sis900.h
+++ b/drivers/net/sis900.h
@@ -33,7 +33,6 @@ enum sis900_registers {
        rxcfg=0x34,             //Receive Configuration Register
        flctrl=0x38,            //Flow Control Register
        rxlen=0x3c,             //Receive Packet Length Register
-        cfgpmcsr=0x44,          //Configuration Power Management Control/Status Register
        rfcr=0x48,              //Receive Filter Control Register
        rfdr=0x4C,              //Receive Filter Data Register
        pmctrl=0xB0,            //Power Management Control Register
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index f8b973a04b65..cae2edf23004 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -23,12 +23,6 @@
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-/*
- * TOTEST
- *      - speed setting
- *      - suspend/resume
- */
 #include <linux/config.h>
 #include <linux/crc32.h>
 #include <linux/kernel.h>
@@ -57,7 +51,7 @@
 #include "sky2.h"
 #define DRV_NAME                "sky2"
-#define DRV_VERSION             "0.13"
+#define DRV_VERSION             "0.15"
 #define PFX                     DRV_NAME " "
 /*
@@ -102,6 +96,10 @@ static int copybreak __read_mostly = 256;
 module_param(copybreak, int, 0);
 MODULE_PARM_DESC(copybreak, "Receive copy threshold");
+static int disable_msi = 0;
+module_param(disable_msi, int, 0);
+MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
 static const struct pci_device_id sky2_id_table[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9000) },
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E00) },
@@ -198,7 +196,7 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
        pci_read_config_word(hw->pdev, hw->pm_cap + PCI_PM_PMC, &power_control);
-        vaux = (sky2_read8(hw, B0_CTST) & Y2_VAUX_AVAIL) &&
+        vaux = (sky2_read16(hw, B0_CTST) & Y2_VAUX_AVAIL) &&
                (power_control & PCI_PM_CAP_PME_D3cold);
        pci_read_config_word(hw->pdev, hw->pm_cap + PCI_PM_CTRL, &power_control);
@@ -1834,6 +1832,8 @@ static int sky2_poll(struct net_device *dev0, int *budget)
        u16 hwidx;
        u16 tx_done[2] = { TX_NO_STATUS, TX_NO_STATUS };
+        sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
        hwidx = sky2_read16(hw, STAT_PUT_IDX);
        BUG_ON(hwidx >= STATUS_RING_SIZE);
        rmb();
@@ -1913,12 +1913,10 @@ static int sky2_poll(struct net_device *dev0, int *budget)
        }
 exit_loop:
-        sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
        sky2_tx_check(hw, 0, tx_done[0]);
        sky2_tx_check(hw, 1, tx_done[1]);
-        if (sky2_read16(hw, STAT_PUT_IDX) == hw->st_idx) {
+        if (likely(work_done < to_do)) {
                /* need to restart TX timer */
                if (is_ec_a1(hw)) {
                        sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP);
@@ -2141,14 +2139,12 @@ static inline u32 sky2_clk2us(const struct sky2_hw *hw, u32 clk)
 static int sky2_reset(struct sky2_hw *hw)
 {
-        u32 ctst;
        u16 status;
        u8 t8, pmd_type;
-        int i;
+        int i, err;
-        ctst = sky2_read32(hw, B0_CTST);
        sky2_write8(hw, B0_CTST, CS_RST_CLR);
        hw->chip_id = sky2_read8(hw, B2_CHIP_ID);
        if (hw->chip_id < CHIP_ID_YUKON_XL || hw->chip_id > CHIP_ID_YUKON_FE) {
                printk(KERN_ERR PFX "%s: unsupported chip type 0x%x\n",
@@ -2156,12 +2152,6 @@ static int sky2_reset(struct sky2_hw *hw)
                return -EOPNOTSUPP;
        }
-        /* ring for status responses */
-        hw->st_le = pci_alloc_consistent(hw->pdev, STATUS_LE_BYTES,
-                                         &hw->st_dma);
-        if (!hw->st_le)
-                return -ENOMEM;
        /* disable ASF */
        if (hw->chip_id <= CHIP_ID_YUKON_EC) {
                sky2_write8(hw, B28_Y2_ASF_STAT_CMD, Y2_ASF_RESET);
@@ -2173,19 +2163,24 @@ static int sky2_reset(struct sky2_hw *hw)
        sky2_write8(hw, B0_CTST, CS_RST_CLR);
        /* clear PCI errors, if any */
-        pci_read_config_word(hw->pdev, PCI_STATUS, &status);
+        err = pci_read_config_word(hw->pdev, PCI_STATUS, &status);
+        if (err)
+                goto pci_err;
        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
-        pci_write_config_word(hw->pdev, PCI_STATUS,
+        err = pci_write_config_word(hw->pdev, PCI_STATUS,
-                              status | PCI_STATUS_ERROR_BITS);
+                                    status | PCI_STATUS_ERROR_BITS);
+        if (err)
+                goto pci_err;
        sky2_write8(hw, B0_CTST, CS_MRST_CLR);
        /* clear any PEX errors */
-        if (is_pciex(hw)) {
+        if (pci_find_capability(hw->pdev, PCI_CAP_ID_EXP)) {
-                u16 lstat;
+                err = pci_write_config_dword(hw->pdev, PEX_UNC_ERR_STAT,
-                pci_write_config_dword(hw->pdev, PEX_UNC_ERR_STAT,
+                                                 0xffffffffUL);
-                                       0xffffffffUL);
+                if (err)
-                pci_read_config_word(hw->pdev, PEX_LNK_STAT, &lstat);
+                        goto pci_err;
        }
        pmd_type = sky2_read8(hw, B2_PMD_TYP);
@@ -2297,6 +2292,14 @@ static int sky2_reset(struct sky2_hw *hw)
        sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START);
        return 0;
+pci_err:
+        /* This is to catch a BIOS bug workaround where
+         * mmconfig table doesn't have other buses.
+         */
+        printk(KERN_ERR PFX "%s: can't access PCI config space\n",
+               pci_name(hw->pdev));
+        return err;
 }
 static u32 sky2_supported_modes(const struct sky2_hw *hw)
@@ -2551,19 +2554,24 @@ static struct net_device_stats *sky2_get_stats(struct net_device *dev)
 static int sky2_set_mac_address(struct net_device *dev, void *p)
 {
        struct sky2_port *sky2 = netdev_priv(dev);
-        struct sockaddr *addr = p;
+        struct sky2_hw *hw = sky2->hw;
+        unsigned port = sky2->port;
+        const struct sockaddr *addr = p;
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
        memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
-        memcpy_toio(sky2->hw->regs + B2_MAC_1 + sky2->port * 8,
+        memcpy_toio(hw->regs + B2_MAC_1 + port * 8,
                    dev->dev_addr, ETH_ALEN);
-        memcpy_toio(sky2->hw->regs + B2_MAC_2 + sky2->port * 8,
+        memcpy_toio(hw->regs + B2_MAC_2 + port * 8,
                    dev->dev_addr, ETH_ALEN);
-        if (netif_running(dev))
+        /* virtual address for data */
-                sky2_phy_reinit(sky2);
+        gma_set_addr(hw, port, GM_SRC_ADDR_2L, dev->dev_addr);
+        /* physical address: used for pause frames */
+        gma_set_addr(hw, port, GM_SRC_ADDR_1L, dev->dev_addr);
        return 0;
 }
@@ -2843,7 +2851,7 @@ static int sky2_set_coalesce(struct net_device *dev,
        if (ecmd->rx_coalesce_usecs_irq == 0)
                sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_STOP);
        else {
-                sky2_write32(hw, STAT_TX_TIMER_INI,
+                sky2_write32(hw, STAT_ISR_TIMER_INI,
                             sky2_us2clk(hw, ecmd->rx_coalesce_usecs_irq));
                sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START);
        }
@@ -3055,6 +3063,61 @@ static void __devinit sky2_show_addr(struct net_device *dev)
                       dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
 }
+/* Handle software interrupt used during MSI test */
+static irqreturn_t __devinit sky2_test_intr(int irq, void *dev_id,
+                                            struct pt_regs *regs)
+{
+        struct sky2_hw *hw = dev_id;
+        u32 status = sky2_read32(hw, B0_Y2_SP_ISRC2);
+        if (status == 0)
+                return IRQ_NONE;
+        if (status & Y2_IS_IRQ_SW) {
+                sky2_write8(hw, B0_CTST, CS_CL_SW_IRQ);
+                hw->msi = 1;
+        }
+        sky2_write32(hw, B0_Y2_SP_ICR, 2);
+        sky2_read32(hw, B0_IMSK);
+        return IRQ_HANDLED;
+}
+/* Test interrupt path by forcing a a software IRQ */
+static int __devinit sky2_test_msi(struct sky2_hw *hw)
+{
+        struct pci_dev *pdev = hw->pdev;
+        int i, err;
+        sky2_write32(hw, B0_IMSK, Y2_IS_IRQ_SW);
+        err = request_irq(pdev->irq, sky2_test_intr, SA_SHIRQ, DRV_NAME, hw);
+        if (err) {
+                printk(KERN_ERR PFX "%s: cannot assign irq %d\n",
+                       pci_name(pdev), pdev->irq);
+                return err;
+        }
+        sky2_write8(hw, B0_CTST, CS_ST_SW_IRQ);
+        wmb();
+        for (i = 0; i < 10; i++) {
+                barrier();
+                if (hw->msi)
+                        goto found;
+                mdelay(1);
+        }
+        err = -EOPNOTSUPP;
+        sky2_write8(hw, B0_CTST, CS_CL_SW_IRQ);
+ found:
+        sky2_write32(hw, B0_IMSK, 0);
+        free_irq(pdev->irq, hw);
+        return err;
+}
 static int __devinit sky2_probe(struct pci_dev *pdev,
                                const struct pci_device_id *ent)
 {
@@ -3135,6 +3198,12 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
        }
        hw->pm_cap = pm_cap;
+        /* ring for status responses */
+        hw->st_le = pci_alloc_consistent(hw->pdev, STATUS_LE_BYTES,
+                                         &hw->st_dma);
+        if (!hw->st_le)
+                goto err_out_iounmap;
        err = sky2_reset(hw);
        if (err)
                goto err_out_iounmap;
@@ -3169,7 +3238,22 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
                }
        }
-        err = request_irq(pdev->irq, sky2_intr, SA_SHIRQ, DRV_NAME, hw);
+        if (!disable_msi && pci_enable_msi(pdev) == 0) {
+                err = sky2_test_msi(hw);
+                if (err == -EOPNOTSUPP) {
+                        /* MSI test failed, go back to INTx mode */
+                        printk(KERN_WARNING PFX "%s: No interrupt was generated using MSI, "
+                               "switching to INTx mode. Please report this failure to "
+                               "the PCI maintainer and include system chipset information.\n",
+                               pci_name(pdev));
+                        pci_disable_msi(pdev);
+                }
+                else if (err)
+                        goto err_out_unregister;
+        }
+        err = request_irq(pdev->irq, sky2_intr, SA_SHIRQ | SA_SAMPLE_RANDOM,
+                          DRV_NAME, hw);
        if (err) {
                printk(KERN_ERR PFX "%s: cannot assign irq %d\n",
                       pci_name(pdev), pdev->irq);
@@ -3184,6 +3268,8 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
        return 0;
 err_out_unregister:
+        if (hw->msi)
+                pci_disable_msi(pdev);
        if (dev1) {
                unregister_netdev(dev1);
                free_netdev(dev1);
@@ -3226,6 +3312,8 @@ static void __devexit sky2_remove(struct pci_dev *pdev)
        sky2_read8(hw, B0_CTST);
        free_irq(pdev->irq, hw);
+        if (hw->msi)
+                pci_disable_msi(pdev);
        pci_free_consistent(pdev, STATUS_LE_BYTES, hw->st_le, hw->st_dma);
        pci_release_regions(pdev);
        pci_disable_device(pdev);
@@ -3263,25 +3351,33 @@ static int sky2_suspend(struct pci_dev *pdev, pm_message_t state)
 static int sky2_resume(struct pci_dev *pdev)
 {
        struct sky2_hw *hw = pci_get_drvdata(pdev);
-        int i;
+        int i, err;
        pci_restore_state(pdev);
        pci_enable_wake(pdev, PCI_D0, 0);
-        sky2_set_power_state(hw, PCI_D0);
+        err = sky2_set_power_state(hw, PCI_D0);
+        if (err)
+                goto out;
-        sky2_reset(hw);
+        err = sky2_reset(hw);
+        if (err)
+                goto out;
        for (i = 0; i < 2; i++) {
                struct net_device *dev = hw->dev[i];
-                if (dev) {
+                if (dev && netif_running(dev)) {
-                        if (netif_running(dev)) {
+                        netif_device_attach(dev);
-                                netif_device_attach(dev);
+                        err = sky2_up(dev);
-                                if (sky2_up(dev))
+                        if (err) {
-                                        dev_close(dev);
+                                printk(KERN_ERR PFX "%s: could not up: %d\n",
+                                       dev->name, err);
+                                dev_close(dev);
+                                break;
                        }
                }
        }
-        return 0;
+out:
+        return err;
 }
 #endif
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h
index 95518921001c..fd12c289a238 100644
--- a/drivers/net/sky2.h
+++ b/drivers/net/sky2.h
@@ -1841,6 +1841,7 @@ struct sky2_hw {
        struct net_device    *dev[2];
        int                  pm_cap;
+        int                  msi;
        u8                   chip_id;
        u8                   chip_rev;
        u8                   copper;
@@ -1867,14 +1868,6 @@ static inline u8 sky2_read8(const struct sky2_hw *hw, unsigned reg)
        return readb(hw->regs + reg);
 }
-/* This should probably go away, bus based tweeks suck */
-static inline int is_pciex(const struct sky2_hw *hw)
-{
-        u32 status;
-        pci_read_config_dword(hw->pdev, PCI_DEV_STATUS, &status);
-        return (status & PCI_OS_PCI_X) == 0;
-}
 static inline void sky2_write32(const struct sky2_hw *hw, unsigned reg, u32 val)
 {
        writel(val, hw->regs + reg);
diff --git a/drivers/net/tulip/uli526x.c b/drivers/net/tulip/uli526x.c
index 983981666800..238e9c72cb3a 100644
--- a/drivers/net/tulip/uli526x.c
+++ b/drivers/net/tulip/uli526x.c
@@ -214,7 +214,7 @@ static u32 uli526x_cr6_user_set;
 /* For module input parameter */
 static int debug;
 static u32 cr6set;
-static unsigned char mode = 8;
+static int mode = 8;
 /* function declaration ------------------------------------- */
 static int uli526x_open(struct net_device *);
diff --git a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c
index 2f61a47b4716..1ff5de076d21 100644
--- a/drivers/net/wan/dscc4.c
+++ b/drivers/net/wan/dscc4.c
@@ -1943,7 +1943,7 @@ static int dscc4_init_ring(struct net_device *dev)
                                        (++i%TX_RING_SIZE)*sizeof(*tx_fd));
        } while (i < TX_RING_SIZE);
-        if (dscc4_init_dummy_skb(dpriv) < 0)
+        if (!dscc4_init_dummy_skb(dpriv))
                goto err_free_dma_tx;
        memset(dpriv->rx_skbuff, 0, sizeof(struct sk_buff *)*RX_RING_SIZE);
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index 8cbf0fc5a225..7f0f35a05dca 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -332,7 +332,7 @@ static _INLINE_ void receive_chars(struct m68k_serial *info, struct pt_regs *reg
                 * Make sure that we do not overflow the buffer
                 */
                if (tty_request_buffer_room(tty, 1) == 0) {
-                        schedule_work(&tty->flip.work);
+                        tty_schedule_flip(tty);
                        return;
                }
@@ -353,7 +353,7 @@ static _INLINE_ void receive_chars(struct m68k_serial *info, struct pt_regs *reg
        } while((rx = uart->urx.w) & URX_DATA_READY);
 #endif
-        schedule_work(&tty->flip.work);
+        tty_schedule_flip(tty);
 clear_and_exit:
        return;
diff --git a/drivers/serial/68360serial.c b/drivers/serial/68360serial.c
index 60f5a5dc17f1..9843ae3d420e 100644
--- a/drivers/serial/68360serial.c
+++ b/drivers/serial/68360serial.c
@@ -509,7 +509,7 @@ static _INLINE_ void receive_chars(ser_info_t *info)
        info->rx_cur = (QUICC_BD *)bdp;
-        schedule_work(&tty->flip.work);
+        tty_schedule_flip(tty);
 }
 static _INLINE_ void receive_break(ser_info_t *info)
@@ -521,7 +521,7 @@ static _INLINE_ void receive_break(ser_info_t *info)
         * the break.  If not, we exit now, losing the break.  FIXME
         */
        tty_insert_flip_char(tty, 0, TTY_BREAK);
-        schedule_work(&tty->flip.work);
+        tty_schedule_flip(tty);
 }
 static _INLINE_ void transmit_chars(ser_info_t *info)
diff --git a/drivers/serial/mcfserial.c b/drivers/serial/mcfserial.c
index 0ef648fa4b2d..8cbbb954df2c 100644
--- a/drivers/serial/mcfserial.c
+++ b/drivers/serial/mcfserial.c
@@ -57,20 +57,16 @@ struct timer_list mcfrs_timer_struct;
 *      keep going.  Perhaps one day the cflag settings for the
 *      console can be used instead.
 */
-#if defined(CONFIG_ARNEWSH) || defined(CONFIG_FREESCALE) || \
-    defined(CONFIG_senTec) || defined(CONFIG_SNEHA)
-#define CONSOLE_BAUD_RATE       19200
-#define DEFAULT_CBAUD           B19200
-#endif
 #if defined(CONFIG_HW_FEITH)
 #define CONSOLE_BAUD_RATE       38400
 #define DEFAULT_CBAUD           B38400
-#endif
+#elif defined(CONFIG_MOD5272) || defined(CONFIG_M5208EVB)
-#if defined(CONFIG_MOD5272) || defined(CONFIG_M5208EVB)
 #define CONSOLE_BAUD_RATE       115200
 #define DEFAULT_CBAUD           B115200
+#elif defined(CONFIG_ARNEWSH) || defined(CONFIG_FREESCALE) || \
+      defined(CONFIG_senTec) || defined(CONFIG_SNEHA)
+#define CONSOLE_BAUD_RATE       19200
+#define DEFAULT_CBAUD           B19200
 #endif
 #ifndef CONSOLE_BAUD_RATE
@@ -350,7 +346,7 @@ static inline void receive_chars(struct mcf_serial *info)
                }
                tty_insert_flip_char(tty, ch, flag);
        }
-        tty_flip_buffer_push(tty);
+        tty_schedule_flip(tty);
        return;
 }