64 files changed, 1259 insertions, 810 deletions

diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 7baeaffefe7a..545f330e59a5 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -426,6 +426,30 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(NVIDIA, 0x0559), board_ahci },            /* MCP67 */
         { PCI_VDEVICE(NVIDIA, 0x055a), board_ahci },            /* MCP67 */
         { PCI_VDEVICE(NVIDIA, 0x055b), board_ahci },            /* MCP67 */
+        { PCI_VDEVICE(NVIDIA, 0x07f0), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f1), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f2), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f3), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f4), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f5), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f6), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f7), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f8), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07f9), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07fa), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x07fb), board_ahci },            /* MCP73 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad0), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad1), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad2), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad3), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad4), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad5), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad6), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad7), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad8), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ad9), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ada), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0adb), board_ahci },            /* MCP77 */
 
         /* SiS */
         { PCI_VDEVICE(SI, 0x1184), board_ahci }, /* SiS 966 */
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 4733f009c7c9..047eabd75363 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -1727,7 +1727,7 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
 
         /* sanity check */
         rc = -EINVAL;
-        reason = "device reports illegal type";
+        reason = "device reports invalid type";
 
         if (class == ATA_DEV_ATA) {
                 if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
@@ -1900,6 +1900,13 @@ int ata_dev_configure(struct ata_device *dev)
         if (ata_msg_probe(ap))
                 ata_dump_id(id);
 
+        /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
+        ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
+                        sizeof(fwrevbuf));
+
+        ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
+                        sizeof(modelbuf));
+
         /* ATA-specific feature tests */
         if (dev->class == ATA_DEV_ATA) {
                 if (ata_id_is_cfa(id)) {
@@ -1914,13 +1921,6 @@ int ata_dev_configure(struct ata_device *dev)
 
                 dev->n_sectors = ata_id_n_sectors(id);
 
-                /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
-                ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
-                                sizeof(fwrevbuf));
-
-                ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
-                                sizeof(modelbuf));
-
                 if (dev->id[59] & 0x100)
                         dev->multi_count = dev->id[59] & 0xff;
 
@@ -2009,7 +2009,9 @@ int ata_dev_configure(struct ata_device *dev)
 
                 /* print device info to dmesg */
                 if (ata_msg_drv(ap) && print_info)
-                        ata_dev_printk(dev, KERN_INFO, "ATAPI, max %s%s\n",
+                        ata_dev_printk(dev, KERN_INFO,
+                                       "ATAPI: %s, %s, max %s%s\n",
+                                       modelbuf, fwrevbuf,
                                        ata_mode_string(xfer_mask),
                                        cdb_intr_string);
         }
@@ -3059,22 +3061,28 @@ static int ata_bus_post_reset(struct ata_port *ap, unsigned int devmask,
                 }
         }
 
-        /* if device 1 was found in ata_devchk, wait for
-         * register access, then wait for BSY to clear
+        /* if device 1 was found in ata_devchk, wait for register
+         * access briefly, then wait for BSY to clear.
          */
-        while (dev1) {
-                u8 nsect, lbal;
+        if (dev1) {
+                int i;
 
                 ap->ops->dev_select(ap, 1);
-                nsect = ioread8(ioaddr->nsect_addr);
-                lbal = ioread8(ioaddr->lbal_addr);
-                if ((nsect == 1) && (lbal == 1))
-                        break;
-                if (time_after(jiffies, deadline))
-                        return -EBUSY;
-                msleep(50);     /* give drive a breather */
-        }
-        if (dev1) {
+
+                /* Wait for register access.  Some ATAPI devices fail
+                 * to set nsect/lbal after reset, so don't waste too
+                 * much time on it.  We're gonna wait for !BSY anyway.
+                 */
+                for (i = 0; i < 2; i++) {
+                        u8 nsect, lbal;
+
+                        nsect = ioread8(ioaddr->nsect_addr);
+                        lbal = ioread8(ioaddr->lbal_addr);
+                        if ((nsect == 1) && (lbal == 1))
+                                break;
+                        msleep(50);     /* give drive a breather */
+                }
+
                 rc = ata_wait_ready(ap, deadline);
                 if (rc) {
                         if (rc != -ENODEV)
@@ -3769,6 +3777,7 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "_NEC DV5800A",       NULL,           ATA_HORKAGE_NODMA },
         { "SAMSUNG CD-ROM SN-124","N001",       ATA_HORKAGE_NODMA },
         { "Seagate STT20000A", NULL,            ATA_HORKAGE_NODMA },
+        { "IOMEGA  ZIP 250       ATAPI", NULL,  ATA_HORKAGE_NODMA }, /* temporary fix */
 
         /* Weird ATAPI devices */
         { "TORiSAN DVD-ROM DRD-N216", NULL,     ATA_HORKAGE_MAX_SEC_128 |
@@ -3791,6 +3800,8 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "HTS541060G9SA00",    "MB3OC60D",     ATA_HORKAGE_NONCQ, },
         { "HTS541080G9SA00",    "MB4OC60D",     ATA_HORKAGE_NONCQ, },
         { "HTS541010G9SA00",    "MBZOC60D",     ATA_HORKAGE_NONCQ, },
+        /* Drives which do spurious command completion */
+        { "HTS541680J9SA00",    "SB2IC7EP",     ATA_HORKAGE_NONCQ, },
 
         /* Devices with NCQ limits */
 
@@ -6313,7 +6324,8 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
                 /* init sata_spd_limit to the current value */
                 if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
                         int spd = (scontrol >> 4) & 0xf;
-                        ap->hw_sata_spd_limit &= (1 << spd) - 1;
+                        if (spd)
+                                ap->hw_sata_spd_limit &= (1 << spd) - 1;
                 }
                 ap->sata_spd_limit = ap->hw_sata_spd_limit;
 
@@ -6433,6 +6445,9 @@ int ata_host_activate(struct ata_host *host, int irq,
         if (rc)
                 devm_free_irq(host->dev, irq, host);
 
+        /* Used to print device info at probe */
+        host->irq = irq;
+
         return rc;
 }
 
@@ -6818,6 +6833,7 @@ EXPORT_SYMBOL_GPL(ata_check_status);
 EXPORT_SYMBOL_GPL(ata_altstatus);
 EXPORT_SYMBOL_GPL(ata_exec_command);
 EXPORT_SYMBOL_GPL(ata_port_start);
+EXPORT_SYMBOL_GPL(ata_sff_port_start);
 EXPORT_SYMBOL_GPL(ata_interrupt);
 EXPORT_SYMBOL_GPL(ata_do_set_mode);
 EXPORT_SYMBOL_GPL(ata_data_xfer);
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index b3900cfbd880..c228df298bd8 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1363,12 +1363,22 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
          * schedule EH_REVALIDATE operation to update the IDENTIFY DEVICE
          * cache
          */
-        if (ap->ops->error_handler &&
-            !need_sense && (qc->tf.command == ATA_CMD_SET_FEATURES) &&
-            ((qc->tf.feature == SETFEATURES_WC_ON) ||
-             (qc->tf.feature == SETFEATURES_WC_OFF))) {
-                ap->eh_info.action |= ATA_EH_REVALIDATE;
-                ata_port_schedule_eh(ap);
+        if (ap->ops->error_handler && !need_sense) {
+                switch (qc->tf.command) {
+                case ATA_CMD_SET_FEATURES:
+                        if ((qc->tf.feature == SETFEATURES_WC_ON) ||
+                            (qc->tf.feature == SETFEATURES_WC_OFF)) {
+                                ap->eh_info.action |= ATA_EH_REVALIDATE;
+                                ata_port_schedule_eh(ap);
+                        }
+                        break;
+
+                case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
+                case ATA_CMD_SET_MULTI: /* multi_count changed */
+                        ap->eh_info.action |= ATA_EH_REVALIDATE;
+                        ata_port_schedule_eh(ap);
+                        break;
+                }
         }
 
         /* For ATA pass thru (SAT) commands, generate a sense block if
@@ -2506,22 +2516,21 @@ ata_scsi_map_proto(u8 byte1)
                         return ATA_PROT_NODATA;
 
                 case 6:         /* DMA */
+                case 10:        /* UDMA Data-in */
+                case 11:        /* UDMA Data-Out */
                         return ATA_PROT_DMA;
 
                 case 4:         /* PIO Data-in */
                 case 5:         /* PIO Data-out */
                         return ATA_PROT_PIO;
 
-                case 10:        /* Device Reset */
                 case 0:         /* Hard Reset */
                 case 1:         /* SRST */
-                case 2:         /* Bus Idle */
-                case 7:         /* Packet */
-                case 8:         /* DMA Queued */
-                case 9:         /* Device Diagnostic */
-                case 11:        /* UDMA Data-in */
-                case 12:        /* UDMA Data-Out */
-                case 13:        /* FPDMA */
+                case 8:         /* Device Diagnostic */
+                case 9:         /* Device Reset */
+                case 7:         /* DMA Queued */
+                case 12:        /* FPDMA */
+                case 15:        /* Return Response Info */
                 default:        /* Reserved */
                         break;
         }
@@ -2552,10 +2561,6 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
         if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
                 goto invalid_fld;
 
-        if (cdb[1] & 0xe0)
-                /* PIO multi not supported yet */
-                goto invalid_fld;
-
         /*
          * 12 and 16 byte CDBs use different offsets to
          * provide the various register values.
@@ -2600,12 +2605,26 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
                 tf->device = cdb[8];
                 tf->command = cdb[9];
         }
-        /*
-         * If slave is possible, enforce correct master/slave bit
-        */
-        if (qc->ap->flags & ATA_FLAG_SLAVE_POSS)
-                tf->device = qc->dev->devno ?
-                        tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
+
+        /* enforce correct master/slave bit */
+        tf->device = dev->devno ?
+                tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
+
+        /* sanity check for pio multi commands */
+        if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf))
+                goto invalid_fld;
+
+        if (is_multi_taskfile(tf)) {
+                unsigned int multi_count = 1 << (cdb[1] >> 5);
+
+                /* compare the passed through multi_count
+                 * with the cached multi_count of libata
+                 */
+                if (multi_count != dev->multi_count)
+                        ata_dev_printk(dev, KERN_WARNING,
+                                       "invalid multi_count %u ignored\n",
+                                       multi_count);
+        }       
 
         /* READ/WRITE LONG use a non-standard sect_size */
         qc->sect_size = ATA_SECT_SIZE;
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index e35d13466c69..ce84805ba5f1 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -80,25 +80,25 @@ u8 ata_dummy_irq_on (struct ata_port *ap) 	{ return 0; }
 u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
 {
         unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
-        u8 host_stat, post_stat, status;
+        u8 host_stat = 0, post_stat = 0, status;
 
         status = ata_busy_wait(ap, bits, 1000);
         if (status & bits)
                 if (ata_msg_err(ap))
                         printk(KERN_ERR "abnormal status 0x%X\n", status);
 
-        /* get controller status; clear intr, err bits */
-        host_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
-        iowrite8(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
-                 ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
-
-        post_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+        if (ap->ioaddr.bmdma_addr) {
+                /* get controller status; clear intr, err bits */
+                host_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+                iowrite8(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
+                         ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 
+                post_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+        }
         if (ata_msg_intr(ap))
                 printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
                         __FUNCTION__,
                         host_stat, post_stat, status);
-
         return status;
 }
 
@@ -516,6 +516,27 @@ void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc)
                 ata_bmdma_stop(qc);
 }
 
+/**
+ *      ata_sff_port_start - Set port up for dma.
+ *      @ap: Port to initialize
+ *
+ *      Called just after data structures for each port are
+ *      initialized.  Allocates space for PRD table if the device
+ *      is DMA capable SFF.
+ *
+ *      May be used as the port_start() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+
+int ata_sff_port_start(struct ata_port *ap)
+{
+        if (ap->ioaddr.bmdma_addr)
+                return ata_port_start(ap);
+        return 0;
+}
+
 #ifdef CONFIG_PCI
 
 static int ata_resources_present(struct pci_dev *pdev, int port)
diff --git a/drivers/ata/pata_isapnp.c b/drivers/ata/pata_isapnp.c
index 1f647b648204..5525518204e6 100644
--- a/drivers/ata/pata_isapnp.c
+++ b/drivers/ata/pata_isapnp.c
@@ -77,7 +77,6 @@ static int isapnp_init_one(struct pnp_dev *idev, const struct pnp_device_id *dev
         struct ata_host *host;
         struct ata_port *ap;
         void __iomem *cmd_addr, *ctl_addr;
-        int rc;
 
         if (pnp_port_valid(idev, 0) == 0)
                 return -ENODEV;
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index 2b924a69b365..6dc0b011a6b7 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -784,9 +784,12 @@ static unsigned int pdc_qc_issue_prot(struct ata_queued_cmd *qc)
                 if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
                         break;
                 /*FALLTHROUGH*/
+        case ATA_PROT_NODATA:
+                if (qc->tf.flags & ATA_TFLAG_POLLING)
+                        break;
+                /*FALLTHROUGH*/
         case ATA_PROT_ATAPI_DMA:
         case ATA_PROT_DMA:
-        case ATA_PROT_NODATA:
                 pdc_packet_start(qc);
                 return 0;
 
@@ -800,7 +803,7 @@ static unsigned int pdc_qc_issue_prot(struct ata_queued_cmd *qc)
 static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         WARN_ON (tf->protocol == ATA_PROT_DMA ||
-                 tf->protocol == ATA_PROT_NODATA);
+                 tf->protocol == ATA_PROT_ATAPI_DMA);
         ata_tf_load(ap, tf);
 }
 
@@ -808,7 +811,7 @@ static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         WARN_ON (tf->protocol == ATA_PROT_DMA ||
-                 tf->protocol == ATA_PROT_NODATA);
+                 tf->protocol == ATA_PROT_ATAPI_DMA);
         ata_exec_command(ap, tf);
 }
 
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 20c4ea6eb50d..8c506dbe3913 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -369,36 +369,6 @@ char *make_class_name(const char *name, struct kobject *kobj)
         return class_name;
 }
 
-static int deprecated_class_uevent(char **envp, int num_envp, int *cur_index,
-                                   char *buffer, int buffer_size,
-                                   int *cur_len,
-                                   struct class_device *class_dev)
-{
-        struct device *dev = class_dev->dev;
-        char *path;
-
-        if (!dev)
-                return 0;
-
-        /* add device, backing this class device (deprecated) */
-        path = kobject_get_path(&dev->kobj, GFP_KERNEL);
-
-        add_uevent_var(envp, num_envp, cur_index, buffer, buffer_size,
-                       cur_len, "PHYSDEVPATH=%s", path);
-        kfree(path);
-
-        if (dev->bus)
-                add_uevent_var(envp, num_envp, cur_index,
-                               buffer, buffer_size, cur_len,
-                               "PHYSDEVBUS=%s", dev->bus->name);
-
-        if (dev->driver)
-                add_uevent_var(envp, num_envp, cur_index,
-                               buffer, buffer_size, cur_len,
-                               "PHYSDEVDRIVER=%s", dev->driver->name);
-        return 0;
-}
-
 static int make_deprecated_class_device_links(struct class_device *class_dev)
 {
         char *class_name;
@@ -430,11 +400,6 @@ static void remove_deprecated_class_device_links(struct class_device *class_dev)
         kfree(class_name);
 }
 #else
-static inline int deprecated_class_uevent(char **envp, int num_envp,
-                                          int *cur_index, char *buffer,
-                                          int buffer_size, int *cur_len,
-                                          struct class_device *class_dev)
-{ return 0; }
 static inline int make_deprecated_class_device_links(struct class_device *cd)
 { return 0; }
 static void remove_deprecated_class_device_links(struct class_device *cd)
@@ -445,15 +410,13 @@ static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp,
                          int num_envp, char *buffer, int buffer_size)
 {
         struct class_device *class_dev = to_class_dev(kobj);
+        struct device *dev = class_dev->dev;
         int i = 0;
         int length = 0;
         int retval = 0;
 
         pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
 
-        deprecated_class_uevent(envp, num_envp, &i, buffer, buffer_size,
-                                &length, class_dev);
-
         if (MAJOR(class_dev->devt)) {
                 add_uevent_var(envp, num_envp, &i,
                                buffer, buffer_size, &length,
@@ -464,6 +427,26 @@ static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp,
                                "MINOR=%u", MINOR(class_dev->devt));
         }
 
+        if (dev) {
+                const char *path = kobject_get_path(&dev->kobj, GFP_KERNEL);
+                if (path) {
+                        add_uevent_var(envp, num_envp, &i,
+                                       buffer, buffer_size, &length,
+                                       "PHYSDEVPATH=%s", path);
+                        kfree(path);
+                }
+
+                if (dev->bus)
+                        add_uevent_var(envp, num_envp, &i,
+                                       buffer, buffer_size, &length,
+                                       "PHYSDEVBUS=%s", dev->bus->name);
+
+                if (dev->driver)
+                        add_uevent_var(envp, num_envp, &i,
+                                       buffer, buffer_size, &length,
+                                       "PHYSDEVDRIVER=%s", dev->driver->name);
+        }
+
         /* terminate, set to next free slot, shrink available space */
         envp[i] = NULL;
         envp = &envp[i];
diff --git a/drivers/base/core.c b/drivers/base/core.c
index b78fc1e68264..dd40d78a023d 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -180,10 +180,12 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
                         const char *path;
 
                         path = kobject_get_path(&parent->kobj, GFP_KERNEL);
-                        add_uevent_var(envp, num_envp, &i,
-                                       buffer, buffer_size, &length,
-                                       "PHYSDEVPATH=%s", path);
-                        kfree(path);
+                        if (path) {
+                                add_uevent_var(envp, num_envp, &i,
+                                               buffer, buffer_size, &length,
+                                               "PHYSDEVPATH=%s", path);
+                                kfree(path);
+                        }
 
                         add_uevent_var(envp, num_envp, &i,
                                        buffer, buffer_size, &length,
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 92428e55b0c2..b0088b0efecd 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -207,19 +207,6 @@ static int __device_attach(struct device_driver * drv, void * data)
         return driver_probe_device(drv, dev);
 }
 
-static int device_probe_drivers(void *data)
-{
-        struct device *dev = data;
-        int ret = 0;
-
-        if (dev->bus) {
-                down(&dev->sem);
-                ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
-                up(&dev->sem);
-        }
-        return ret;
-}
-
 /**
  *      device_attach - try to attach device to a driver.
  *      @dev:   device.
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 97ab5bd1c4d6..89a5f4a54913 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -1,7 +1,7 @@
 /*
  * firmware_class.c - Multi purpose firmware loading support
  *
- * Copyright (c) 2003 Manuel Estrada Sainz <ranty@debian.org>
+ * Copyright (c) 2003 Manuel Estrada Sainz
  *
  * Please see Documentation/firmware_class/ for more information.
  *
@@ -23,7 +23,7 @@
 
 #define to_dev(obj) container_of(obj, struct device, kobj)
 
-MODULE_AUTHOR("Manuel Estrada Sainz <ranty@debian.org>");
+MODULE_AUTHOR("Manuel Estrada Sainz");
 MODULE_DESCRIPTION("Multi purpose firmware loading support");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 5526eadb6592..0ed5470d2533 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1354,7 +1354,7 @@ static struct block_device_operations lo_fops = {
  */
 static int max_loop;
 module_param(max_loop, int, 0);
-MODULE_PARM_DESC(max_loop, "obsolete, loop device is created on-demand");
+MODULE_PARM_DESC(max_loop, "Maximum number of loop devices");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR);
 
@@ -1394,16 +1394,11 @@ int loop_unregister_transfer(int number)
 EXPORT_SYMBOL(loop_register_transfer);
 EXPORT_SYMBOL(loop_unregister_transfer);
 
-static struct loop_device *loop_init_one(int i)
+static struct loop_device *loop_alloc(int i)
 {
         struct loop_device *lo;
         struct gendisk *disk;
 
-        list_for_each_entry(lo, &loop_devices, lo_list) {
-                if (lo->lo_number == i)
-                        return lo;
-        }
-
         lo = kzalloc(sizeof(*lo), GFP_KERNEL);
         if (!lo)
                 goto out;
@@ -1427,8 +1422,6 @@ static struct loop_device *loop_init_one(int i)
         disk->private_data      = lo;
         disk->queue             = lo->lo_queue;
         sprintf(disk->disk_name, "loop%d", i);
-        add_disk(disk);
-        list_add_tail(&lo->lo_list, &loop_devices);
         return lo;
 
 out_free_queue:
@@ -1439,15 +1432,37 @@ out:
         return NULL;
 }
 
-static void loop_del_one(struct loop_device *lo)
+static void loop_free(struct loop_device *lo)
 {
-        del_gendisk(lo->lo_disk);
         blk_cleanup_queue(lo->lo_queue);
         put_disk(lo->lo_disk);
         list_del(&lo->lo_list);
         kfree(lo);
 }
 
+static struct loop_device *loop_init_one(int i)
+{
+        struct loop_device *lo;
+
+        list_for_each_entry(lo, &loop_devices, lo_list) {
+                if (lo->lo_number == i)
+                        return lo;
+        }
+
+        lo = loop_alloc(i);
+        if (lo) {
+                add_disk(lo->lo_disk);
+                list_add_tail(&lo->lo_list, &loop_devices);
+        }
+        return lo;
+}
+
+static void loop_del_one(struct loop_device *lo)
+{
+        del_gendisk(lo->lo_disk);
+        loop_free(lo);
+}
+
 static struct kobject *loop_probe(dev_t dev, int *part, void *data)
 {
         struct loop_device *lo;
@@ -1464,28 +1479,77 @@ static struct kobject *loop_probe(dev_t dev, int *part, void *data)
 
 static int __init loop_init(void)
 {
-        if (register_blkdev(LOOP_MAJOR, "loop"))
-                return -EIO;
-        blk_register_region(MKDEV(LOOP_MAJOR, 0), 1UL << MINORBITS,
-                                  THIS_MODULE, loop_probe, NULL, NULL);
+        int i, nr;
+        unsigned long range;
+        struct loop_device *lo, *next;
+
+        /*
+         * loop module now has a feature to instantiate underlying device
+         * structure on-demand, provided that there is an access dev node.
+         * However, this will not work well with user space tool that doesn't
+         * know about such "feature".  In order to not break any existing
+         * tool, we do the following:
+         *
+         * (1) if max_loop is specified, create that many upfront, and this
+         *     also becomes a hard limit.
+         * (2) if max_loop is not specified, create 8 loop device on module
+         *     load, user can further extend loop device by create dev node
+         *     themselves and have kernel automatically instantiate actual
+         *     device on-demand.
+         */
+        if (max_loop > 1UL << MINORBITS)
+                return -EINVAL;
 
         if (max_loop) {
-                printk(KERN_INFO "loop: the max_loop option is obsolete "
-                                 "and will be removed in March 2008\n");
+                nr = max_loop;
+                range = max_loop;
+        } else {
+                nr = 8;
+                range = 1UL << MINORBITS;
+        }
+
+        if (register_blkdev(LOOP_MAJOR, "loop"))
+                return -EIO;
 
+        for (i = 0; i < nr; i++) {
+                lo = loop_alloc(i);
+                if (!lo)
+                        goto Enomem;
+                list_add_tail(&lo->lo_list, &loop_devices);
         }
+
+        /* point of no return */
+
+        list_for_each_entry(lo, &loop_devices, lo_list)
+                add_disk(lo->lo_disk);
+
+        blk_register_region(MKDEV(LOOP_MAJOR, 0), range,
+                                  THIS_MODULE, loop_probe, NULL, NULL);
+
         printk(KERN_INFO "loop: module loaded\n");
         return 0;
+
+Enomem:
+        printk(KERN_INFO "loop: out of memory\n");
+
+        list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
+                loop_free(lo);
+
+        unregister_blkdev(LOOP_MAJOR, "loop");
+        return -ENOMEM;
 }
 
 static void __exit loop_exit(void)
 {
+        unsigned long range;
         struct loop_device *lo, *next;
 
+        range = max_loop ? max_loop :  1UL << MINORBITS;
+
         list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
                 loop_del_one(lo);
 
-        blk_unregister_region(MKDEV(LOOP_MAJOR, 0), 1UL << MINORBITS);
+        blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range);
         if (unregister_blkdev(LOOP_MAJOR, "loop"))
                 printk(KERN_WARNING "loop: cannot unregister blkdev\n");
 }
diff --git a/drivers/cdrom/mcdx.c b/drivers/cdrom/mcdx.c
index f574962f4288..4310cc84dfed 100644
--- a/drivers/cdrom/mcdx.c
+++ b/drivers/cdrom/mcdx.c
@@ -1053,11 +1053,11 @@ static void __exit mcdx_exit(void)
         if (unregister_blkdev(MAJOR_NR, "mcdx") != 0) {
                 xwarn("cleanup() unregister_blkdev() failed\n");
         }
-        blk_cleanup_queue(mcdx_queue);
 #if !MCDX_QUIET
         else
         xinfo("cleanup() succeeded\n");
 #endif
+        blk_cleanup_queue(mcdx_queue);
 }
 
 #ifdef MODULE
diff --git a/drivers/char/agp/agp.h b/drivers/char/agp/agp.h
index fdbca25a3948..35ab1a9f8e8b 100644
--- a/drivers/char/agp/agp.h
+++ b/drivers/char/agp/agp.h
@@ -176,7 +176,7 @@ struct agp_bridge_data {
 #define I830_GMCH_MEM_MASK              0x1
 #define I830_GMCH_MEM_64M               0x1
 #define I830_GMCH_MEM_128M              0
-#define I830_GMCH_GMS_MASK              0x70
+#define I830_GMCH_GMS_MASK              0xF0
 #define I830_GMCH_GMS_DISABLED          0x00
 #define I830_GMCH_GMS_LOCAL             0x10
 #define I830_GMCH_GMS_STOLEN_512        0x20
@@ -231,6 +231,10 @@ struct agp_bridge_data {
 #define I965_PGETBL_SIZE_512KB  (0 << 1)
 #define I965_PGETBL_SIZE_256KB  (1 << 1)
 #define I965_PGETBL_SIZE_128KB  (2 << 1)
+#define G33_PGETBL_SIZE_MASK    (3 << 8)
+#define G33_PGETBL_SIZE_1M      (1 << 8)
+#define G33_PGETBL_SIZE_2M      (2 << 8)
+
 #define I810_DRAM_CTL           0x3000
 #define I810_DRAM_ROW_0         0x00000001
 #define I810_DRAM_ROW_0_SDRAM   0x00000001
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index 9c69f2e761f5..d383168b75fa 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -20,6 +20,14 @@
 #define PCI_DEVICE_ID_INTEL_82965G_IG       0x29A2
 #define PCI_DEVICE_ID_INTEL_82965GM_HB      0x2A00
 #define PCI_DEVICE_ID_INTEL_82965GM_IG      0x2A02
+#define PCI_DEVICE_ID_INTEL_82965GME_IG     0x2A12
+#define PCI_DEVICE_ID_INTEL_82945GME_IG     0x27AE
+#define PCI_DEVICE_ID_INTEL_G33_HB          0x29C0
+#define PCI_DEVICE_ID_INTEL_G33_IG          0x29C2
+#define PCI_DEVICE_ID_INTEL_Q35_HB          0x29B0
+#define PCI_DEVICE_ID_INTEL_Q35_IG          0x29B2
+#define PCI_DEVICE_ID_INTEL_Q33_HB          0x29D0
+#define PCI_DEVICE_ID_INTEL_Q33_IG          0x29D2
 
 #define IS_I965 (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82946GZ_HB || \
                  agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965G_1_HB || \
@@ -27,6 +35,9 @@
                  agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965G_HB || \
                  agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965GM_HB)
 
+#define IS_G33 (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_G33_HB || \
+                agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_Q35_HB || \
+                agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_Q33_HB)
 
 extern int agp_memory_reserved;
 
@@ -53,6 +64,8 @@ extern int agp_memory_reserved;
 #define I915_PTEADDR    0x1C
 #define I915_GMCH_GMS_STOLEN_48M        (0x6 << 4)
 #define I915_GMCH_GMS_STOLEN_64M        (0x7 << 4)
+#define G33_GMCH_GMS_STOLEN_128M       (0x8 << 4)
+#define G33_GMCH_GMS_STOLEN_256M       (0x9 << 4)
 
 /* Intel 965G registers */
 #define I965_MSAC 0x62
@@ -86,11 +99,18 @@ static struct gatt_mask intel_i810_masks[] =
          .type = INTEL_AGP_CACHED_MEMORY}
 };
 
-static struct _intel_i810_private {
-        struct pci_dev *i810_dev;       /* device one */
-        volatile u8 __iomem *registers;
+static struct _intel_private {
+        struct pci_dev *pcidev; /* device one */
+        u8 __iomem *registers;
+        u32 __iomem *gtt;               /* I915G */
         int num_dcache_entries;
-} intel_i810_private;
+        /* gtt_entries is the number of gtt entries that are already mapped
+         * to stolen memory.  Stolen memory is larger than the memory mapped
+         * through gtt_entries, as it includes some reserved space for the BIOS
+         * popup and for the GTT.
+         */
+        int gtt_entries;                        /* i830+ */
+} intel_private;
 
 static int intel_i810_fetch_size(void)
 {
@@ -127,32 +147,32 @@ static int intel_i810_configure(void)
 
         current_size = A_SIZE_FIX(agp_bridge->current_size);
 
-        if (!intel_i810_private.registers) {
-                pci_read_config_dword(intel_i810_private.i810_dev, I810_MMADDR, &temp);
+        if (!intel_private.registers) {
+                pci_read_config_dword(intel_private.pcidev, I810_MMADDR, &temp);
                 temp &= 0xfff80000;
 
-                intel_i810_private.registers = ioremap(temp, 128 * 4096);
-                if (!intel_i810_private.registers) {
+                intel_private.registers = ioremap(temp, 128 * 4096);
+                if (!intel_private.registers) {
                         printk(KERN_ERR PFX "Unable to remap memory.\n");
                         return -ENOMEM;
                 }
         }
 
-        if ((readl(intel_i810_private.registers+I810_DRAM_CTL)
+        if ((readl(intel_private.registers+I810_DRAM_CTL)
                 & I810_DRAM_ROW_0) == I810_DRAM_ROW_0_SDRAM) {
                 /* This will need to be dynamically assigned */
                 printk(KERN_INFO PFX "detected 4MB dedicated video ram.\n");
-                intel_i810_private.num_dcache_entries = 1024;
+                intel_private.num_dcache_entries = 1024;
         }
-        pci_read_config_dword(intel_i810_private.i810_dev, I810_GMADDR, &temp);
+        pci_read_config_dword(intel_private.pcidev, I810_GMADDR, &temp);
         agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
-        writel(agp_bridge->gatt_bus_addr | I810_PGETBL_ENABLED, intel_i810_private.registers+I810_PGETBL_CTL);
-        readl(intel_i810_private.registers+I810_PGETBL_CTL);    /* PCI Posting. */
+        writel(agp_bridge->gatt_bus_addr | I810_PGETBL_ENABLED, intel_private.registers+I810_PGETBL_CTL);
+        readl(intel_private.registers+I810_PGETBL_CTL); /* PCI Posting. */
 
         if (agp_bridge->driver->needs_scratch_page) {
                 for (i = 0; i < current_size->num_entries; i++) {
-                        writel(agp_bridge->scratch_page, intel_i810_private.registers+I810_PTE_BASE+(i*4));
-                        readl(intel_i810_private.registers+I810_PTE_BASE+(i*4));        /* PCI posting. */
+                        writel(agp_bridge->scratch_page, intel_private.registers+I810_PTE_BASE+(i*4));
+                        readl(intel_private.registers+I810_PTE_BASE+(i*4));     /* PCI posting. */
                 }
         }
         global_cache_flush();
@@ -161,9 +181,9 @@ static int intel_i810_configure(void)
 
 static void intel_i810_cleanup(void)
 {
-        writel(0, intel_i810_private.registers+I810_PGETBL_CTL);
-        readl(intel_i810_private.registers);    /* PCI Posting. */
-        iounmap(intel_i810_private.registers);
+        writel(0, intel_private.registers+I810_PGETBL_CTL);
+        readl(intel_private.registers); /* PCI Posting. */
+        iounmap(intel_private.registers);
 }
 
 static void intel_i810_tlbflush(struct agp_memory *mem)
@@ -261,9 +281,9 @@ static int intel_i810_insert_entries(struct agp_memory *mem, off_t pg_start,
                         global_cache_flush();
                 for (i = pg_start; i < (pg_start + mem->page_count); i++) {
                         writel((i*4096)|I810_PTE_LOCAL|I810_PTE_VALID,
-                               intel_i810_private.registers+I810_PTE_BASE+(i*4));
+                               intel_private.registers+I810_PTE_BASE+(i*4));
                 }
-                readl(intel_i810_private.registers+I810_PTE_BASE+((i-1)*4));
+                readl(intel_private.registers+I810_PTE_BASE+((i-1)*4));
                 break;
         case AGP_PHYS_MEMORY:
         case AGP_NORMAL_MEMORY:
@@ -273,9 +293,9 @@ static int intel_i810_insert_entries(struct agp_memory *mem, off_t pg_start,
                         writel(agp_bridge->driver->mask_memory(agp_bridge,
                                                                mem->memory[i],
                                                                mask_type),
-                               intel_i810_private.registers+I810_PTE_BASE+(j*4));
+                               intel_private.registers+I810_PTE_BASE+(j*4));
                 }
-                readl(intel_i810_private.registers+I810_PTE_BASE+((j-1)*4));
+                readl(intel_private.registers+I810_PTE_BASE+((j-1)*4));
                 break;
         default:
                 goto out_err;
@@ -298,9 +318,9 @@ static int intel_i810_remove_entries(struct agp_memory *mem, off_t pg_start,
                 return 0;
 
         for (i = pg_start; i < (mem->page_count + pg_start); i++) {
-                writel(agp_bridge->scratch_page, intel_i810_private.registers+I810_PTE_BASE+(i*4));
+                writel(agp_bridge->scratch_page, intel_private.registers+I810_PTE_BASE+(i*4));
         }
-        readl(intel_i810_private.registers+I810_PTE_BASE+((i-1)*4));
+        readl(intel_private.registers+I810_PTE_BASE+((i-1)*4));
 
         agp_bridge->driver->tlb_flush(mem);
         return 0;
@@ -354,7 +374,7 @@ static struct agp_memory *intel_i810_alloc_by_type(size_t pg_count, int type)
         struct agp_memory *new;
 
         if (type == AGP_DCACHE_MEMORY) {
-                if (pg_count != intel_i810_private.num_dcache_entries)
+                if (pg_count != intel_private.num_dcache_entries)
                         return NULL;
 
                 new = agp_create_memory(1);
@@ -404,18 +424,6 @@ static struct aper_size_info_fixed intel_i830_sizes[] =
         {512, 131072, 7},
 };
 
-static struct _intel_i830_private {
-        struct pci_dev *i830_dev;               /* device one */
-        volatile u8 __iomem *registers;
-        volatile u32 __iomem *gtt;              /* I915G */
-        /* gtt_entries is the number of gtt entries that are already mapped
-         * to stolen memory.  Stolen memory is larger than the memory mapped
-         * through gtt_entries, as it includes some reserved space for the BIOS
-         * popup and for the GTT.
-         */
-        int gtt_entries;
-} intel_i830_private;
-
 static void intel_i830_init_gtt_entries(void)
 {
         u16 gmch_ctrl;
@@ -429,7 +437,7 @@ static void intel_i830_init_gtt_entries(void)
 
         if (IS_I965) {
                 u32 pgetbl_ctl;
-                pgetbl_ctl = readl(intel_i830_private.registers+I810_PGETBL_CTL);
+                pgetbl_ctl = readl(intel_private.registers+I810_PGETBL_CTL);
 
                 /* The 965 has a field telling us the size of the GTT,
                  * which may be larger than what is necessary to map the
@@ -451,6 +459,22 @@ static void intel_i830_init_gtt_entries(void)
                         size = 512;
                 }
                 size += 4; /* add in BIOS popup space */
+        } else if (IS_G33) {
+        /* G33's GTT size defined in gmch_ctrl */
+                switch (gmch_ctrl & G33_PGETBL_SIZE_MASK) {
+                case G33_PGETBL_SIZE_1M:
+                        size = 1024;
+                        break;
+                case G33_PGETBL_SIZE_2M:
+                        size = 2048;
+                        break;
+                default:
+                        printk(KERN_INFO PFX "Unknown page table size 0x%x, "
+                                "assuming 512KB\n",
+                                (gmch_ctrl & G33_PGETBL_SIZE_MASK));
+                        size = 512;
+                }
+                size += 4;
         } else {
                 /* On previous hardware, the GTT size was just what was
                  * required to map the aperture.
@@ -471,7 +495,7 @@ static void intel_i830_init_gtt_entries(void)
                         gtt_entries = MB(8) - KB(size);
                         break;
                 case I830_GMCH_GMS_LOCAL:
-                        rdct = readb(intel_i830_private.registers+I830_RDRAM_CHANNEL_TYPE);
+                        rdct = readb(intel_private.registers+I830_RDRAM_CHANNEL_TYPE);
                         gtt_entries = (I830_RDRAM_ND(rdct) + 1) *
                                         MB(ddt[I830_RDRAM_DDT(rdct)]);
                         local = 1;
@@ -502,7 +526,8 @@ static void intel_i830_init_gtt_entries(void)
                         if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB ||
-                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB || IS_I965 )
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB ||
+                            IS_I965 || IS_G33)
                                 gtt_entries = MB(48) - KB(size);
                         else
                                 gtt_entries = 0;
@@ -512,10 +537,24 @@ static void intel_i830_init_gtt_entries(void)
                         if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB ||
-                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB || IS_I965)
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB ||
+                            IS_I965 || IS_G33)
                                 gtt_entries = MB(64) - KB(size);
                         else
                                 gtt_entries = 0;
+                        break;
+                case G33_GMCH_GMS_STOLEN_128M:
+                        if (IS_G33)
+                                gtt_entries = MB(128) - KB(size);
+                        else
+                                gtt_entries = 0;
+                        break;
+                case G33_GMCH_GMS_STOLEN_256M:
+                        if (IS_G33)
+                                gtt_entries = MB(256) - KB(size);
+                        else
+                                gtt_entries = 0;
+                        break;
                 default:
                         gtt_entries = 0;
                         break;
@@ -529,7 +568,7 @@ static void intel_i830_init_gtt_entries(void)
                        "No pre-allocated video memory detected.\n");
         gtt_entries /= KB(4);
 
-        intel_i830_private.gtt_entries = gtt_entries;
+        intel_private.gtt_entries = gtt_entries;
 }
 
 /* The intel i830 automatically initializes the agp aperture during POST.
@@ -547,14 +586,14 @@ static int intel_i830_create_gatt_table(struct agp_bridge_data *bridge)
         num_entries = size->num_entries;
         agp_bridge->gatt_table_real = NULL;
 
-        pci_read_config_dword(intel_i830_private.i830_dev,I810_MMADDR,&temp);
+        pci_read_config_dword(intel_private.pcidev,I810_MMADDR,&temp);
         temp &= 0xfff80000;
 
-        intel_i830_private.registers = ioremap(temp,128 * 4096);
-        if (!intel_i830_private.registers)
+        intel_private.registers = ioremap(temp,128 * 4096);
+        if (!intel_private.registers)
                 return -ENOMEM;
 
-        temp = readl(intel_i830_private.registers+I810_PGETBL_CTL) & 0xfffff000;
+        temp = readl(intel_private.registers+I810_PGETBL_CTL) & 0xfffff000;
         global_cache_flush();   /* FIXME: ?? */
 
         /* we have to call this as early as possible after the MMIO base address is known */
@@ -614,20 +653,20 @@ static int intel_i830_configure(void)
 
         current_size = A_SIZE_FIX(agp_bridge->current_size);
 
-        pci_read_config_dword(intel_i830_private.i830_dev,I810_GMADDR,&temp);
+        pci_read_config_dword(intel_private.pcidev,I810_GMADDR,&temp);
         agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
 
         pci_read_config_word(agp_bridge->dev,I830_GMCH_CTRL,&gmch_ctrl);
         gmch_ctrl |= I830_GMCH_ENABLED;
         pci_write_config_word(agp_bridge->dev,I830_GMCH_CTRL,gmch_ctrl);
 
-        writel(agp_bridge->gatt_bus_addr|I810_PGETBL_ENABLED, intel_i830_private.registers+I810_PGETBL_CTL);
-        readl(intel_i830_private.registers+I810_PGETBL_CTL);    /* PCI Posting. */
+        writel(agp_bridge->gatt_bus_addr|I810_PGETBL_ENABLED, intel_private.registers+I810_PGETBL_CTL);
+        readl(intel_private.registers+I810_PGETBL_CTL); /* PCI Posting. */
 
         if (agp_bridge->driver->needs_scratch_page) {
-                for (i = intel_i830_private.gtt_entries; i < current_size->num_entries; i++) {
-                        writel(agp_bridge->scratch_page, intel_i830_private.registers+I810_PTE_BASE+(i*4));
-                        readl(intel_i830_private.registers+I810_PTE_BASE+(i*4));        /* PCI Posting. */
+                for (i = intel_private.gtt_entries; i < current_size->num_entries; i++) {
+                        writel(agp_bridge->scratch_page, intel_private.registers+I810_PTE_BASE+(i*4));
+                        readl(intel_private.registers+I810_PTE_BASE+(i*4));     /* PCI Posting. */
                 }
         }
 
@@ -637,7 +676,7 @@ static int intel_i830_configure(void)
 
 static void intel_i830_cleanup(void)
 {
-        iounmap(intel_i830_private.registers);
+        iounmap(intel_private.registers);
 }
 
 static int intel_i830_insert_entries(struct agp_memory *mem,off_t pg_start, int type)
@@ -653,9 +692,9 @@ static int intel_i830_insert_entries(struct agp_memory *mem,off_t pg_start, int
         temp = agp_bridge->current_size;
         num_entries = A_SIZE_FIX(temp)->num_entries;
 
-        if (pg_start < intel_i830_private.gtt_entries) {
-                printk (KERN_DEBUG PFX "pg_start == 0x%.8lx,intel_i830_private.gtt_entries == 0x%.8x\n",
-                                pg_start,intel_i830_private.gtt_entries);
+        if (pg_start < intel_private.gtt_entries) {
+                printk (KERN_DEBUG PFX "pg_start == 0x%.8lx,intel_private.gtt_entries == 0x%.8x\n",
+                                pg_start,intel_private.gtt_entries);
 
                 printk (KERN_INFO PFX "Trying to insert into local/stolen memory\n");
                 goto out_err;
@@ -683,9 +722,9 @@ static int intel_i830_insert_entries(struct agp_memory *mem,off_t pg_start, int
         for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
                 writel(agp_bridge->driver->mask_memory(agp_bridge,
                                                        mem->memory[i], mask_type),
-                       intel_i830_private.registers+I810_PTE_BASE+(j*4));
+                       intel_private.registers+I810_PTE_BASE+(j*4));
         }
-        readl(intel_i830_private.registers+I810_PTE_BASE+((j-1)*4));
+        readl(intel_private.registers+I810_PTE_BASE+((j-1)*4));
         agp_bridge->driver->tlb_flush(mem);
 
 out:
@@ -703,15 +742,15 @@ static int intel_i830_remove_entries(struct agp_memory *mem,off_t pg_start,
         if (mem->page_count == 0)
                 return 0;
 
-        if (pg_start < intel_i830_private.gtt_entries) {
+        if (pg_start < intel_private.gtt_entries) {
                 printk (KERN_INFO PFX "Trying to disable local/stolen memory\n");
                 return -EINVAL;
         }
 
         for (i = pg_start; i < (mem->page_count + pg_start); i++) {
-                writel(agp_bridge->scratch_page, intel_i830_private.registers+I810_PTE_BASE+(i*4));
+                writel(agp_bridge->scratch_page, intel_private.registers+I810_PTE_BASE+(i*4));
         }
-        readl(intel_i830_private.registers+I810_PTE_BASE+((i-1)*4));
+        readl(intel_private.registers+I810_PTE_BASE+((i-1)*4));
 
         agp_bridge->driver->tlb_flush(mem);
         return 0;
@@ -734,7 +773,7 @@ static int intel_i915_configure(void)
 
         current_size = A_SIZE_FIX(agp_bridge->current_size);
 
-        pci_read_config_dword(intel_i830_private.i830_dev, I915_GMADDR, &temp);
+        pci_read_config_dword(intel_private.pcidev, I915_GMADDR, &temp);
 
         agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
 
@@ -742,13 +781,13 @@ static int intel_i915_configure(void)
         gmch_ctrl |= I830_GMCH_ENABLED;
         pci_write_config_word(agp_bridge->dev,I830_GMCH_CTRL,gmch_ctrl);
 
-        writel(agp_bridge->gatt_bus_addr|I810_PGETBL_ENABLED, intel_i830_private.registers+I810_PGETBL_CTL);
-        readl(intel_i830_private.registers+I810_PGETBL_CTL);    /* PCI Posting. */
+        writel(agp_bridge->gatt_bus_addr|I810_PGETBL_ENABLED, intel_private.registers+I810_PGETBL_CTL);
+        readl(intel_private.registers+I810_PGETBL_CTL); /* PCI Posting. */
 
         if (agp_bridge->driver->needs_scratch_page) {
-                for (i = intel_i830_private.gtt_entries; i < current_size->num_entries; i++) {
-                        writel(agp_bridge->scratch_page, intel_i830_private.gtt+i);
-                        readl(intel_i830_private.gtt+i);        /* PCI Posting. */
+                for (i = intel_private.gtt_entries; i < current_size->num_entries; i++) {
+                        writel(agp_bridge->scratch_page, intel_private.gtt+i);
+                        readl(intel_private.gtt+i);     /* PCI Posting. */
                 }
         }
 
@@ -758,8 +797,8 @@ static int intel_i915_configure(void)
 
 static void intel_i915_cleanup(void)
 {
-        iounmap(intel_i830_private.gtt);
-        iounmap(intel_i830_private.registers);
+        iounmap(intel_private.gtt);
+        iounmap(intel_private.registers);
 }
 
 static int intel_i915_insert_entries(struct agp_memory *mem,off_t pg_start,
@@ -776,9 +815,9 @@ static int intel_i915_insert_entries(struct agp_memory *mem,off_t pg_start,
         temp = agp_bridge->current_size;
         num_entries = A_SIZE_FIX(temp)->num_entries;
 
-        if (pg_start < intel_i830_private.gtt_entries) {
-                printk (KERN_DEBUG PFX "pg_start == 0x%.8lx,intel_i830_private.gtt_entries == 0x%.8x\n",
-                                pg_start,intel_i830_private.gtt_entries);
+        if (pg_start < intel_private.gtt_entries) {
+                printk (KERN_DEBUG PFX "pg_start == 0x%.8lx,intel_private.gtt_entries == 0x%.8x\n",
+                                pg_start,intel_private.gtt_entries);
 
                 printk (KERN_INFO PFX "Trying to insert into local/stolen memory\n");
                 goto out_err;
@@ -805,10 +844,10 @@ static int intel_i915_insert_entries(struct agp_memory *mem,off_t pg_start,
 
         for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
                 writel(agp_bridge->driver->mask_memory(agp_bridge,
-                        mem->memory[i], mask_type), intel_i830_private.gtt+j);
+                        mem->memory[i], mask_type), intel_private.gtt+j);
         }
 
-        readl(intel_i830_private.gtt+j-1);
+        readl(intel_private.gtt+j-1);
         agp_bridge->driver->tlb_flush(mem);
 
  out:
@@ -826,15 +865,15 @@ static int intel_i915_remove_entries(struct agp_memory *mem,off_t pg_start,
         if (mem->page_count == 0)
                 return 0;
 
-        if (pg_start < intel_i830_private.gtt_entries) {
+        if (pg_start < intel_private.gtt_entries) {
                 printk (KERN_INFO PFX "Trying to disable local/stolen memory\n");
                 return -EINVAL;
         }
 
         for (i = pg_start; i < (mem->page_count + pg_start); i++) {
-                writel(agp_bridge->scratch_page, intel_i830_private.gtt+i);
+                writel(agp_bridge->scratch_page, intel_private.gtt+i);
         }
-        readl(intel_i830_private.gtt+i-1);
+        readl(intel_private.gtt+i-1);
 
         agp_bridge->driver->tlb_flush(mem);
         return 0;
@@ -850,7 +889,7 @@ static int intel_i9xx_fetch_size(void)
         int aper_size; /* size in megabytes */
         int i;
 
-        aper_size = pci_resource_len(intel_i830_private.i830_dev, 2) / MB(1);
+        aper_size = pci_resource_len(intel_private.pcidev, 2) / MB(1);
 
         for (i = 0; i < num_sizes; i++) {
                 if (aper_size == intel_i830_sizes[i].size) {
@@ -878,20 +917,20 @@ static int intel_i915_create_gatt_table(struct agp_bridge_data *bridge)
         num_entries = size->num_entries;
         agp_bridge->gatt_table_real = NULL;
 
-        pci_read_config_dword(intel_i830_private.i830_dev, I915_MMADDR, &temp);
-        pci_read_config_dword(intel_i830_private.i830_dev, I915_PTEADDR,&temp2);
+        pci_read_config_dword(intel_private.pcidev, I915_MMADDR, &temp);
+        pci_read_config_dword(intel_private.pcidev, I915_PTEADDR,&temp2);
 
-        intel_i830_private.gtt = ioremap(temp2, 256 * 1024);
-        if (!intel_i830_private.gtt)
+        intel_private.gtt = ioremap(temp2, 256 * 1024);
+        if (!intel_private.gtt)
                 return -ENOMEM;
 
         temp &= 0xfff80000;
 
-        intel_i830_private.registers = ioremap(temp,128 * 4096);
-        if (!intel_i830_private.registers)
+        intel_private.registers = ioremap(temp,128 * 4096);
+        if (!intel_private.registers)
                 return -ENOMEM;
 
-        temp = readl(intel_i830_private.registers+I810_PGETBL_CTL) & 0xfffff000;
+        temp = readl(intel_private.registers+I810_PGETBL_CTL) & 0xfffff000;
         global_cache_flush();   /* FIXME: ? */
 
         /* we have to call this as early as possible after the MMIO base address is known */
@@ -938,20 +977,20 @@ static int intel_i965_create_gatt_table(struct agp_bridge_data *bridge)
        num_entries = size->num_entries;
        agp_bridge->gatt_table_real = NULL;
 
-       pci_read_config_dword(intel_i830_private.i830_dev, I915_MMADDR, &temp);
+       pci_read_config_dword(intel_private.pcidev, I915_MMADDR, &temp);
 
        temp &= 0xfff00000;
-       intel_i830_private.gtt = ioremap((temp + (512 * 1024)) , 512 * 1024);
+       intel_private.gtt = ioremap((temp + (512 * 1024)) , 512 * 1024);
 
-       if (!intel_i830_private.gtt)
+       if (!intel_private.gtt)
                return -ENOMEM;
 
 
-       intel_i830_private.registers = ioremap(temp,128 * 4096);
-       if (!intel_i830_private.registers)
+       intel_private.registers = ioremap(temp,128 * 4096);
+       if (!intel_private.registers)
                return -ENOMEM;
 
-       temp = readl(intel_i830_private.registers+I810_PGETBL_CTL) & 0xfffff000;
+       temp = readl(intel_private.registers+I810_PGETBL_CTL) & 0xfffff000;
        global_cache_flush();   /* FIXME: ? */
 
        /* we have to call this as early as possible after the MMIO base address is known */
@@ -1722,41 +1761,126 @@ static const struct agp_bridge_driver intel_7505_driver = {
         .agp_type_to_mask_type  = agp_generic_type_to_mask_type,
 };
 
-static int find_i810(u16 device)
-{
-        struct pci_dev *i810_dev;
-
-        i810_dev = pci_get_device(PCI_VENDOR_ID_INTEL, device, NULL);
-        if (!i810_dev)
-                return 0;
-        intel_i810_private.i810_dev = i810_dev;
-        return 1;
-}
+static const struct agp_bridge_driver intel_g33_driver = {
+        .owner                  = THIS_MODULE,
+        .aperture_sizes         = intel_i830_sizes,
+        .size_type              = FIXED_APER_SIZE,
+        .num_aperture_sizes     = 4,
+        .needs_scratch_page     = TRUE,
+        .configure              = intel_i915_configure,
+        .fetch_size             = intel_i9xx_fetch_size,
+        .cleanup                = intel_i915_cleanup,
+        .tlb_flush              = intel_i810_tlbflush,
+        .mask_memory            = intel_i965_mask_memory,
+        .masks                  = intel_i810_masks,
+        .agp_enable             = intel_i810_agp_enable,
+        .cache_flush            = global_cache_flush,
+        .create_gatt_table      = intel_i915_create_gatt_table,
+        .free_gatt_table        = intel_i830_free_gatt_table,
+        .insert_memory          = intel_i915_insert_entries,
+        .remove_memory          = intel_i915_remove_entries,
+        .alloc_by_type          = intel_i830_alloc_by_type,
+        .free_by_type           = intel_i810_free_by_type,
+        .agp_alloc_page         = agp_generic_alloc_page,
+        .agp_destroy_page       = agp_generic_destroy_page,
+        .agp_type_to_mask_type  = intel_i830_type_to_mask_type,
+};
 
-static int find_i830(u16 device)
+static int find_gmch(u16 device)
 {
-        struct pci_dev *i830_dev;
+        struct pci_dev *gmch_device;
 
-        i830_dev = pci_get_device(PCI_VENDOR_ID_INTEL, device, NULL);
-        if (i830_dev && PCI_FUNC(i830_dev->devfn) != 0) {
-                i830_dev = pci_get_device(PCI_VENDOR_ID_INTEL,
-                                device, i830_dev);
+        gmch_device = pci_get_device(PCI_VENDOR_ID_INTEL, device, NULL);
+        if (gmch_device && PCI_FUNC(gmch_device->devfn) != 0) {
+                gmch_device = pci_get_device(PCI_VENDOR_ID_INTEL,
+                                device, gmch_device);
         }
 
-        if (!i830_dev)
+        if (!gmch_device)
                 return 0;
 
-        intel_i830_private.i830_dev = i830_dev;
+        intel_private.pcidev = gmch_device;
         return 1;
 }
 
+/* Table to describe Intel GMCH and AGP/PCIE GART drivers.  At least one of
+ * driver and gmch_driver must be non-null, and find_gmch will determine
+ * which one should be used if a gmch_chip_id is present.
+ */
+static const struct intel_driver_description {
+        unsigned int chip_id;
+        unsigned int gmch_chip_id;
+        char *name;
+        const struct agp_bridge_driver *driver;
+        const struct agp_bridge_driver *gmch_driver;
+} intel_agp_chipsets[] = {
+        { PCI_DEVICE_ID_INTEL_82443LX_0, 0, "440LX", &intel_generic_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82443BX_0, 0, "440BX", &intel_generic_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82443GX_0, 0, "440GX", &intel_generic_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82810_MC1, PCI_DEVICE_ID_INTEL_82810_IG1, "i810",
+                NULL, &intel_810_driver },
+        { PCI_DEVICE_ID_INTEL_82810_MC3, PCI_DEVICE_ID_INTEL_82810_IG3, "i810",
+                NULL, &intel_810_driver },
+        { PCI_DEVICE_ID_INTEL_82810E_MC, PCI_DEVICE_ID_INTEL_82810E_IG, "i810",
+                NULL, &intel_810_driver },
+        { PCI_DEVICE_ID_INTEL_82815_MC, PCI_DEVICE_ID_INTEL_82815_CGC, "i815",
+                &intel_810_driver, &intel_815_driver },
+        { PCI_DEVICE_ID_INTEL_82820_HB, 0, "i820", &intel_820_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82820_UP_HB, 0, "i820", &intel_820_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82830_HB, PCI_DEVICE_ID_INTEL_82830_CGC, "830M",
+                &intel_830mp_driver, &intel_830_driver },
+        { PCI_DEVICE_ID_INTEL_82840_HB, 0, "i840", &intel_840_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82845_HB, 0, "845G", &intel_845_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82845G_HB, PCI_DEVICE_ID_INTEL_82845G_IG, "830M",
+                &intel_845_driver, &intel_830_driver },
+        { PCI_DEVICE_ID_INTEL_82850_HB, 0, "i850", &intel_850_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82855PM_HB, 0, "855PM", &intel_845_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82855GM_HB, PCI_DEVICE_ID_INTEL_82855GM_IG, "855GM",
+                &intel_845_driver, &intel_830_driver },
+        { PCI_DEVICE_ID_INTEL_82860_HB, 0, "i860", &intel_860_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82865_HB, PCI_DEVICE_ID_INTEL_82865_IG, "865",
+                &intel_845_driver, &intel_830_driver },
+        { PCI_DEVICE_ID_INTEL_82875_HB, 0, "i875", &intel_845_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_82915G_HB, PCI_DEVICE_ID_INTEL_82915G_IG, "915G",
+                &intel_845_driver, &intel_915_driver },
+        { PCI_DEVICE_ID_INTEL_82915GM_HB, PCI_DEVICE_ID_INTEL_82915GM_IG, "915GM",
+                &intel_845_driver, &intel_915_driver },
+        { PCI_DEVICE_ID_INTEL_82945G_HB, PCI_DEVICE_ID_INTEL_82945G_IG, "945G",
+                &intel_845_driver, &intel_915_driver },
+        { PCI_DEVICE_ID_INTEL_82945GM_HB, PCI_DEVICE_ID_INTEL_82945GM_IG, "945GM",
+                &intel_845_driver, &intel_915_driver },
+        { PCI_DEVICE_ID_INTEL_82945GM_HB, PCI_DEVICE_ID_INTEL_82945GME_IG, "945GME",
+                &intel_845_driver, &intel_915_driver },
+        { PCI_DEVICE_ID_INTEL_82946GZ_HB, PCI_DEVICE_ID_INTEL_82946GZ_IG, "946GZ",
+                &intel_845_driver, &intel_i965_driver },
+        { PCI_DEVICE_ID_INTEL_82965G_1_HB, PCI_DEVICE_ID_INTEL_82965G_1_IG, "965G",
+                &intel_845_driver, &intel_i965_driver },
+        { PCI_DEVICE_ID_INTEL_82965Q_HB, PCI_DEVICE_ID_INTEL_82965Q_IG, "965Q",
+                &intel_845_driver, &intel_i965_driver },
+        { PCI_DEVICE_ID_INTEL_82965G_HB, PCI_DEVICE_ID_INTEL_82965G_IG, "965G",
+                &intel_845_driver, &intel_i965_driver },
+        { PCI_DEVICE_ID_INTEL_82965GM_HB, PCI_DEVICE_ID_INTEL_82965GM_IG, "965GM",
+                &intel_845_driver, &intel_i965_driver },
+        { PCI_DEVICE_ID_INTEL_82965GM_HB, PCI_DEVICE_ID_INTEL_82965GME_IG, "965GME/GLE",
+                &intel_845_driver, &intel_i965_driver },
+        { PCI_DEVICE_ID_INTEL_7505_0, 0, "E7505", &intel_7505_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_7205_0, 0, "E7205", &intel_7505_driver, NULL },
+        { PCI_DEVICE_ID_INTEL_G33_HB, PCI_DEVICE_ID_INTEL_G33_IG, "G33",
+                &intel_845_driver, &intel_g33_driver },
+        { PCI_DEVICE_ID_INTEL_Q35_HB, PCI_DEVICE_ID_INTEL_Q35_IG, "Q35",
+                &intel_845_driver, &intel_g33_driver },
+        { PCI_DEVICE_ID_INTEL_Q33_HB, PCI_DEVICE_ID_INTEL_Q33_IG, "Q33",
+                &intel_845_driver, &intel_g33_driver },
+        { 0, 0, NULL, NULL, NULL }
+};
+
 static int __devinit agp_intel_probe(struct pci_dev *pdev,
                                      const struct pci_device_id *ent)
 {
         struct agp_bridge_data *bridge;
-        char *name = "(unknown)";
         u8 cap_ptr = 0;
         struct resource *r;
+        int i;
 
         cap_ptr = pci_find_capability(pdev, PCI_CAP_ID_AGP);
 
@@ -1764,195 +1888,42 @@ static int __devinit agp_intel_probe(struct pci_dev *pdev,
         if (!bridge)
                 return -ENOMEM;
 
-        switch (pdev->device) {
-        case PCI_DEVICE_ID_INTEL_82443LX_0:
-                bridge->driver = &intel_generic_driver;
-                name = "440LX";
-                break;
-        case PCI_DEVICE_ID_INTEL_82443BX_0:
-                bridge->driver = &intel_generic_driver;
-                name = "440BX";
-                break;
-        case PCI_DEVICE_ID_INTEL_82443GX_0:
-                bridge->driver = &intel_generic_driver;
-                name = "440GX";
-                break;
-        case PCI_DEVICE_ID_INTEL_82810_MC1:
-                name = "i810";
-                if (!find_i810(PCI_DEVICE_ID_INTEL_82810_IG1))
-                        goto fail;
-                bridge->driver = &intel_810_driver;
-                break;
-        case PCI_DEVICE_ID_INTEL_82810_MC3:
-                name = "i810 DC100";
-                if (!find_i810(PCI_DEVICE_ID_INTEL_82810_IG3))
-                        goto fail;
-                bridge->driver = &intel_810_driver;
-                break;
-        case PCI_DEVICE_ID_INTEL_82810E_MC:
-                name = "i810 E";
-                if (!find_i810(PCI_DEVICE_ID_INTEL_82810E_IG))
-                        goto fail;
-                bridge->driver = &intel_810_driver;
-                break;
-         case PCI_DEVICE_ID_INTEL_82815_MC:
-                /*
-                 * The i815 can operate either as an i810 style
-                 * integrated device, or as an AGP4X motherboard.
-                 */
-                if (find_i810(PCI_DEVICE_ID_INTEL_82815_CGC))
-                        bridge->driver = &intel_810_driver;
-                else
-                        bridge->driver = &intel_815_driver;
-                name = "i815";
-                break;
-        case PCI_DEVICE_ID_INTEL_82820_HB:
-        case PCI_DEVICE_ID_INTEL_82820_UP_HB:
-                bridge->driver = &intel_820_driver;
-                name = "i820";
-                break;
-        case PCI_DEVICE_ID_INTEL_82830_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82830_CGC))
-                        bridge->driver = &intel_830_driver;
-                else
-                        bridge->driver = &intel_830mp_driver;
-                name = "830M";
-                break;
-        case PCI_DEVICE_ID_INTEL_82840_HB:
-                bridge->driver = &intel_840_driver;
-                name = "i840";
-                break;
-        case PCI_DEVICE_ID_INTEL_82845_HB:
-                bridge->driver = &intel_845_driver;
-                name = "i845";
-                break;
-        case PCI_DEVICE_ID_INTEL_82845G_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82845G_IG))
-                        bridge->driver = &intel_830_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "845G";
-                break;
-        case PCI_DEVICE_ID_INTEL_82850_HB:
-                bridge->driver = &intel_850_driver;
-                name = "i850";
-                break;
-        case PCI_DEVICE_ID_INTEL_82855PM_HB:
-                bridge->driver = &intel_845_driver;
-                name = "855PM";
-                break;
-        case PCI_DEVICE_ID_INTEL_82855GM_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82855GM_IG)) {
-                        bridge->driver = &intel_830_driver;
-                        name = "855";
-                } else {
-                        bridge->driver = &intel_845_driver;
-                        name = "855GM";
-                }
-                break;
-        case PCI_DEVICE_ID_INTEL_82860_HB:
-                bridge->driver = &intel_860_driver;
-                name = "i860";
-                break;
-        case PCI_DEVICE_ID_INTEL_82865_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82865_IG))
-                        bridge->driver = &intel_830_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "865";
-                break;
-        case PCI_DEVICE_ID_INTEL_82875_HB:
-                bridge->driver = &intel_845_driver;
-                name = "i875";
-                break;
-        case PCI_DEVICE_ID_INTEL_82915G_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82915G_IG))
-                        bridge->driver = &intel_915_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "915G";
-                break;
-        case PCI_DEVICE_ID_INTEL_82915GM_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82915GM_IG))
-                        bridge->driver = &intel_915_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "915GM";
-                break;
-        case PCI_DEVICE_ID_INTEL_82945G_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82945G_IG))
-                        bridge->driver = &intel_915_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "945G";
-                break;
-        case PCI_DEVICE_ID_INTEL_82945GM_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82945GM_IG))
-                        bridge->driver = &intel_915_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "945GM";
-                break;
-        case PCI_DEVICE_ID_INTEL_82946GZ_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82946GZ_IG))
-                        bridge->driver = &intel_i965_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "946GZ";
-                break;
-        case PCI_DEVICE_ID_INTEL_82965G_1_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82965G_1_IG))
-                        bridge->driver = &intel_i965_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "965G";
-                break;
-        case PCI_DEVICE_ID_INTEL_82965Q_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82965Q_IG))
-                        bridge->driver = &intel_i965_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "965Q";
-                break;
-        case PCI_DEVICE_ID_INTEL_82965G_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82965G_IG))
-                        bridge->driver = &intel_i965_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "965G";
-                break;
-        case PCI_DEVICE_ID_INTEL_82965GM_HB:
-                if (find_i830(PCI_DEVICE_ID_INTEL_82965GM_IG))
-                        bridge->driver = &intel_i965_driver;
-                else
-                        bridge->driver = &intel_845_driver;
-                name = "965GM";
-                break;
-        case PCI_DEVICE_ID_INTEL_7505_0:
-                bridge->driver = &intel_7505_driver;
-                name = "E7505";
-                break;
-        case PCI_DEVICE_ID_INTEL_7205_0:
-                bridge->driver = &intel_7505_driver;
-                name = "E7205";
-                break;
-        default:
+        for (i = 0; intel_agp_chipsets[i].name != NULL; i++) {
+                /* In case that multiple models of gfx chip may
+                   stand on same host bridge type, this can be
+                   sure we detect the right IGD. */
+                if ((pdev->device == intel_agp_chipsets[i].chip_id) &&
+                        ((intel_agp_chipsets[i].gmch_chip_id == 0) ||
+                                find_gmch(intel_agp_chipsets[i].gmch_chip_id)))
+                        break;
+        }
+
+        if (intel_agp_chipsets[i].name == NULL) {
                 if (cap_ptr)
-                        printk(KERN_WARNING PFX "Unsupported Intel chipset (device id: %04x)\n",
-                            pdev->device);
+                        printk(KERN_WARNING PFX "Unsupported Intel chipset"
+                               "(device id: %04x)\n", pdev->device);
                 agp_put_bridge(bridge);
                 return -ENODEV;
-        };
+        }
+
+        if (intel_agp_chipsets[i].gmch_chip_id != 0)
+            bridge->driver = intel_agp_chipsets[i].gmch_driver;
+        else
+            bridge->driver = intel_agp_chipsets[i].driver;
+
+        if (bridge->driver == NULL) {
+                printk(KERN_WARNING PFX "Failed to find bridge device "
+                        "(chip_id: %04x)\n", intel_agp_chipsets[i].gmch_chip_id);
+                agp_put_bridge(bridge);
+                return -ENODEV;
+        }
 
         bridge->dev = pdev;
         bridge->capndx = cap_ptr;
+        bridge->dev_private_data = &intel_private;
 
-        if (bridge->driver == &intel_810_driver)
-                bridge->dev_private_data = &intel_i810_private;
-        else if (bridge->driver == &intel_830_driver)
-                bridge->dev_private_data = &intel_i830_private;
-
-        printk(KERN_INFO PFX "Detected an Intel %s Chipset.\n", name);
+        printk(KERN_INFO PFX "Detected an Intel %s Chipset.\n",
+                intel_agp_chipsets[i].name);
 
         /*
         * The following fixes the case where the BIOS has "forgotten" to
@@ -1988,12 +1959,6 @@ static int __devinit agp_intel_probe(struct pci_dev *pdev,
 
         pci_set_drvdata(pdev, bridge);
         return agp_add_bridge(bridge);
-
-fail:
-        printk(KERN_ERR PFX "Detected an Intel %s chipset, "
-                "but could not find the secondary device.\n", name);
-        agp_put_bridge(bridge);
-        return -ENODEV;
 }
 
 static void __devexit agp_intel_remove(struct pci_dev *pdev)
@@ -2002,10 +1967,8 @@ static void __devexit agp_intel_remove(struct pci_dev *pdev)
 
         agp_remove_bridge(bridge);
 
-        if (intel_i810_private.i810_dev)
-                pci_dev_put(intel_i810_private.i810_dev);
-        if (intel_i830_private.i830_dev)
-                pci_dev_put(intel_i830_private.i830_dev);
+        if (intel_private.pcidev)
+                pci_dev_put(intel_private.pcidev);
 
         agp_put_bridge(bridge);
 }
@@ -2021,10 +1984,8 @@ static int agp_intel_resume(struct pci_dev *pdev)
          * as host bridge (00:00) resumes before graphics device (02:00),
          * then our access to its pci space can work right.
          */
-        if (intel_i810_private.i810_dev)
-                pci_restore_state(intel_i810_private.i810_dev);
-        if (intel_i830_private.i830_dev)
-                pci_restore_state(intel_i830_private.i830_dev);
+        if (intel_private.pcidev)
+                pci_restore_state(intel_private.pcidev);
 
         if (bridge->driver == &intel_generic_driver)
                 intel_configure();
@@ -2087,6 +2048,9 @@ static struct pci_device_id agp_intel_pci_table[] = {
         ID(PCI_DEVICE_ID_INTEL_82965Q_HB),
         ID(PCI_DEVICE_ID_INTEL_82965G_HB),
         ID(PCI_DEVICE_ID_INTEL_82965GM_HB),
+        ID(PCI_DEVICE_ID_INTEL_G33_HB),
+        ID(PCI_DEVICE_ID_INTEL_Q35_HB),
+        ID(PCI_DEVICE_ID_INTEL_Q33_HB),
         { }
 };
 
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index e45113a7a472..45bf2a262a85 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -2172,11 +2172,12 @@ static int __devinit stl_initech(struct stlbrd *brdp)
                 }
                 status = inb(ioaddr + ECH_PNLSTATUS);
                 if ((status & ECH_PNLIDMASK) != nxtid)
-                        goto err_fr;
+                        break;
                 panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
                 if (!panelp) {
                         printk("STALLION: failed to allocate memory "
                                 "(size=%Zd)\n", sizeof(struct stlpanel));
+                        retval = -ENOMEM;
                         goto err_fr;
                 }
                 panelp->magic = STL_PANELMAGIC;
@@ -2223,8 +2224,10 @@ static int __devinit stl_initech(struct stlbrd *brdp)
                 brdp->nrports += panelp->nrports;
                 brdp->panels[panelnr++] = panelp;
                 if ((brdp->brdtype != BRD_ECHPCI) &&
-                    (ioaddr >= (brdp->ioaddr2 + brdp->iosize2)))
+                    (ioaddr >= (brdp->ioaddr2 + brdp->iosize2))) {
+                        retval = -EINVAL;
                         goto err_fr;
+                }
         }
 
         brdp->nrpanels = panelnr;
@@ -2371,6 +2374,7 @@ static int __devinit stl_pciprobe(struct pci_dev *pdev,
                 dev_err(&pdev->dev, "too many boards found, "
                         "maximum supported %d\n", STL_MAXBRDS);
                 mutex_unlock(&stl_brdslock);
+                retval = -ENODEV;
                 goto err_fr;
         }
         brdp->brdnr = (unsigned int)brdnr;
@@ -4710,6 +4714,29 @@ static int __init stallion_module_init(void)
         spin_lock_init(&stallion_lock);
         spin_lock_init(&brd_lock);
 
+        stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
+        if (!stl_serial) {
+                retval = -ENOMEM;
+                goto err;
+        }
+
+        stl_serial->owner = THIS_MODULE;
+        stl_serial->driver_name = stl_drvname;
+        stl_serial->name = "ttyE";
+        stl_serial->major = STL_SERIALMAJOR;
+        stl_serial->minor_start = 0;
+        stl_serial->type = TTY_DRIVER_TYPE_SERIAL;
+        stl_serial->subtype = SERIAL_TYPE_NORMAL;
+        stl_serial->init_termios = stl_deftermios;
+        stl_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+        tty_set_operations(stl_serial, &stl_ops);
+
+        retval = tty_register_driver(stl_serial);
+        if (retval) {
+                printk("STALLION: failed to register serial driver\n");
+                goto err_frtty;
+        }
+
 /*
  *      Find any dynamically supported boards. That is via module load
  *      line options.
@@ -4739,13 +4766,9 @@ static int __init stallion_module_init(void)
 
         /* this has to be _after_ isa finding because of locking */
         retval = pci_register_driver(&stl_pcidriver);
-        if (retval && stl_nrbrds == 0)
-                goto err;
-
-        stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
-        if (!stl_serial) {
-                retval = -ENOMEM;
-                goto err_pcidr;
+        if (retval && stl_nrbrds == 0) {
+                printk(KERN_ERR "STALLION: can't register pci driver\n");
+                goto err_unrtty;
         }
 
 /*
@@ -4756,43 +4779,18 @@ static int __init stallion_module_init(void)
                 printk("STALLION: failed to register serial board device\n");
 
         stallion_class = class_create(THIS_MODULE, "staliomem");
-        if (IS_ERR(stallion_class)) {
-                retval = PTR_ERR(stallion_class);
-                goto err_reg;
-        }
+        if (IS_ERR(stallion_class))
+                printk("STALLION: failed to create class\n");
         for (i = 0; i < 4; i++)
                 class_device_create(stallion_class, NULL,
                                     MKDEV(STL_SIOMEMMAJOR, i), NULL,
                                     "staliomem%d", i);
 
-        stl_serial->owner = THIS_MODULE;
-        stl_serial->driver_name = stl_drvname;
-        stl_serial->name = "ttyE";
-        stl_serial->major = STL_SERIALMAJOR;
-        stl_serial->minor_start = 0;
-        stl_serial->type = TTY_DRIVER_TYPE_SERIAL;
-        stl_serial->subtype = SERIAL_TYPE_NORMAL;
-        stl_serial->init_termios = stl_deftermios;
-        stl_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
-        tty_set_operations(stl_serial, &stl_ops);
-
-        retval = tty_register_driver(stl_serial);
-        if (retval) {
-                printk("STALLION: failed to register serial driver\n");
-                goto err_clsdev;
-        }
-
         return 0;
-err_clsdev:
-        for (i = 0; i < 4; i++)
-                class_device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
-        class_destroy(stallion_class);
-err_reg:
-        unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
+err_unrtty:
+        tty_unregister_driver(stl_serial);
+err_frtty:
         put_tty_driver(stl_serial);
-err_pcidr:
-        pci_unregister_driver(&stl_pcidriver);
-        stl_free_isabrds();
 err:
         return retval;
 }
@@ -4821,8 +4819,6 @@ static void __exit stallion_module_exit(void)
                         tty_unregister_device(stl_serial,
                                 brdp->brdnr * STL_MAXPORTS + j);
         }
-        tty_unregister_driver(stl_serial);
-        put_tty_driver(stl_serial);
 
         for (i = 0; i < 4; i++)
                 class_device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
@@ -4834,6 +4830,9 @@ static void __exit stallion_module_exit(void)
         pci_unregister_driver(&stl_pcidriver);
 
         stl_free_isabrds();
+
+        tty_unregister_driver(stl_serial);
+        put_tty_driver(stl_serial);
 }
 
 module_init(stallion_module_init);
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 7fff773f2df7..dc2175c81f5e 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -1037,6 +1037,17 @@ static void ide_disk_release(struct kref *kref)
 
 static int ide_disk_probe(ide_drive_t *drive);
 
+/*
+ * On HPA drives the capacity needs to be
+ * reinitilized on resume otherwise the disk
+ * can not be used and a hard reset is required
+ */
+static void ide_disk_resume(ide_drive_t *drive)
+{
+        if (idedisk_supports_hpa(drive->id))
+                init_idedisk_capacity(drive);
+}
+
 static void ide_device_shutdown(ide_drive_t *drive)
 {
 #ifdef  CONFIG_ALPHA
@@ -1071,6 +1082,7 @@ static ide_driver_t idedisk_driver = {
         },
         .probe                  = ide_disk_probe,
         .remove                 = ide_disk_remove,
+        .resume                 = ide_disk_resume,
         .shutdown               = ide_device_shutdown,
         .version                = IDEDISK_VERSION,
         .media                  = ide_disk,
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 3cebed77f55d..41bfa4d21ab6 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -717,7 +717,7 @@ EXPORT_SYMBOL_GPL(ide_undecoded_slave);
  * This routine only knows how to look for drive units 0 and 1
  * on an interface, so any setting of MAX_DRIVES > 2 won't work here.
  */
-static void probe_hwif(ide_hwif_t *hwif)
+static void probe_hwif(ide_hwif_t *hwif, void (*fixup)(ide_hwif_t *hwif))
 {
         unsigned int unit;
         unsigned long flags;
@@ -820,6 +820,9 @@ static void probe_hwif(ide_hwif_t *hwif)
                 return;
         }
 
+        if (fixup)
+                fixup(hwif);
+
         for (unit = 0; unit < MAX_DRIVES; ++unit) {
                 ide_drive_t *drive = &hwif->drives[unit];
 
@@ -874,10 +877,7 @@ static int hwif_init(ide_hwif_t *hwif);
 
 int probe_hwif_init_with_fixup(ide_hwif_t *hwif, void (*fixup)(ide_hwif_t *hwif))
 {
-        probe_hwif(hwif);
-
-        if (fixup)
-                fixup(hwif);
+        probe_hwif(hwif, fixup);
 
         if (!hwif_init(hwif)) {
                 printk(KERN_INFO "%s: failed to initialize IDE interface\n",
@@ -1404,7 +1404,7 @@ int ideprobe_init (void)
 
         for (index = 0; index < MAX_HWIFS; ++index)
                 if (probe[index])
-                        probe_hwif(&ide_hwifs[index]);
+                        probe_hwif(&ide_hwifs[index], NULL);
         for (index = 0; index < MAX_HWIFS; ++index)
                 if (probe[index])
                         hwif_init(&ide_hwifs[index]);
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 6002713a20a1..0af0d1614f75 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -1010,9 +1010,11 @@ static int generic_ide_resume(struct device *dev)
 {
         ide_drive_t *drive = dev->driver_data;
         ide_hwif_t *hwif = HWIF(drive);
+        ide_driver_t *drv = to_ide_driver(dev->driver);
         struct request rq;
         struct request_pm_state rqpm;
         ide_task_t args;
+        int err;
 
         /* Call ACPI _STM only once */
         if (!(drive->dn % 2))
@@ -1029,7 +1031,12 @@ static int generic_ide_resume(struct device *dev)
         rqpm.pm_step = ide_pm_state_start_resume;
         rqpm.pm_state = PM_EVENT_ON;
 
-        return ide_do_drive_cmd(drive, &rq, ide_head_wait);
+        err = ide_do_drive_cmd(drive, &rq, ide_head_wait);
+
+        if (err == 0 && drv && drv->resume)
+                drv->resume(drive);
+
+        return err;
 }
 
 int generic_ide_ioctl(ide_drive_t *drive, struct file *file, struct block_device *bdev,
diff --git a/drivers/ide/pci/amd74xx.c b/drivers/ide/pci/amd74xx.c
index becb1a5648b0..9db1be826e80 100644
--- a/drivers/ide/pci/amd74xx.c
+++ b/drivers/ide/pci/amd74xx.c
@@ -1,5 +1,5 @@
 /*
- * Version 2.13
+ * Version 2.15
  *
  * AMD 755/756/766/8111 and nVidia nForce/2/2s/3/3s/CK804/MCP04
  * IDE driver for Linux.
@@ -76,6 +76,8 @@ static struct amd_ide_chip {
         { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE,        0x50, AMD_UDMA_133 },
         { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_IDE,        0x50, AMD_UDMA_133 },
         { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_IDE,        0x50, AMD_UDMA_133 },
+        { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_IDE,        0x50, AMD_UDMA_133 },
+        { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP77_IDE,        0x50, AMD_UDMA_133 },
         { PCI_DEVICE_ID_AMD_CS5536_IDE,                 0x40, AMD_UDMA_100 },
         { 0 }
 };
@@ -494,7 +496,9 @@ static ide_pci_device_t amd74xx_chipsets[] __devinitdata = {
         /* 17 */ DECLARE_NV_DEV("NFORCE-MCP61"),
         /* 18 */ DECLARE_NV_DEV("NFORCE-MCP65"),
         /* 19 */ DECLARE_NV_DEV("NFORCE-MCP67"),
-        /* 20 */ DECLARE_AMD_DEV("AMD5536"),
+        /* 20 */ DECLARE_NV_DEV("NFORCE-MCP73"),
+        /* 21 */ DECLARE_NV_DEV("NFORCE-MCP77"),
+        /* 22 */ DECLARE_AMD_DEV("AMD5536"),
 };
 
 static int __devinit amd74xx_probe(struct pci_dev *dev, const struct pci_device_id *id)
@@ -534,7 +538,9 @@ static struct pci_device_id amd74xx_pci_tbl[] = {
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 17 },
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 18 },
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 19 },
-        { PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_CS5536_IDE,           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 20 },
+        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 20 },
+        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP77_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 21 },
+        { PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_CS5536_IDE,           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 22 },
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, amd74xx_pci_tbl);
diff --git a/drivers/ide/pci/generic.c b/drivers/ide/pci/generic.c
index f2c5a141ca10..0d51a11e81da 100644
--- a/drivers/ide/pci/generic.c
+++ b/drivers/ide/pci/generic.c
@@ -198,32 +198,41 @@ static ide_pci_device_t generic_chipsets[] __devinitdata = {
 static int __devinit generic_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
         ide_pci_device_t *d = &generic_chipsets[id->driver_data];
-        u16 command;
         int ret = -ENODEV;
 
         /* Don't use the generic entry unless instructed to do so */
         if (id->driver_data == 0 && ide_generic_all == 0)
                         goto out;
 
-        if (dev->vendor == PCI_VENDOR_ID_UMC &&
-            dev->device == PCI_DEVICE_ID_UMC_UM8886A &&
-            (!(PCI_FUNC(dev->devfn) & 1)))
-                goto out; /* UM8886A/BF pair */
-
-        if (dev->vendor == PCI_VENDOR_ID_OPTI &&
-            dev->device == PCI_DEVICE_ID_OPTI_82C558 &&
-            (!(PCI_FUNC(dev->devfn) & 1)))
-                goto out;
-
-        if (dev->vendor == PCI_VENDOR_ID_JMICRON) {
-                if (dev->device != PCI_DEVICE_ID_JMICRON_JMB368 && PCI_FUNC(dev->devfn) != 1)
+        switch (dev->vendor) {
+        case PCI_VENDOR_ID_UMC:
+                if (dev->device == PCI_DEVICE_ID_UMC_UM8886A &&
+                                !(PCI_FUNC(dev->devfn) & 1))
+                        goto out; /* UM8886A/BF pair */
+                break;
+        case PCI_VENDOR_ID_OPTI:
+                if (dev->device == PCI_DEVICE_ID_OPTI_82C558 &&
+                                !(PCI_FUNC(dev->devfn) & 1))
+                        goto out;
+                break;
+        case PCI_VENDOR_ID_JMICRON:
+                if (dev->device != PCI_DEVICE_ID_JMICRON_JMB368 &&
+                                PCI_FUNC(dev->devfn) != 1)
+                        goto out;
+                break;
+        case PCI_VENDOR_ID_NS:
+                if (dev->device == PCI_DEVICE_ID_NS_87410 &&
+                                (dev->class >> 8) != PCI_CLASS_STORAGE_IDE)
                         goto out;
+                break;
         }
 
         if (dev->vendor != PCI_VENDOR_ID_JMICRON) {
+                u16 command;
                 pci_read_config_word(dev, PCI_COMMAND, &command);
                 if (!(command & PCI_COMMAND_IO)) {
-                        printk(KERN_INFO "Skipping disabled %s IDE controller.\n", d->name);
+                        printk(KERN_INFO "Skipping disabled %s IDE "
+                                        "controller.\n", d->name);
                         goto out;
                 }
         }
diff --git a/drivers/ide/pci/hpt366.c b/drivers/ide/pci/hpt366.c
index fcbc5605b38e..ce8a5449a574 100644
--- a/drivers/ide/pci/hpt366.c
+++ b/drivers/ide/pci/hpt366.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/ide/pci/hpt366.c               Version 1.03    May 4, 2007
+ * linux/drivers/ide/pci/hpt366.c               Version 1.04    Jun 4, 2007
  *
  * Copyright (C) 1999-2003              Andre Hedrick <andre@linux-ide.org>
  * Portions Copyright (C) 2001          Sun Microsystems, Inc.
@@ -106,7 +106,8 @@
  *   switch  to calculating  PCI clock frequency based on the chip's base DPLL
  *   frequency
  * - switch to using the  DPLL clock and enable UltraATA/133 mode by default on
- *   anything  newer than HPT370/A
+ *   anything  newer than HPT370/A (except HPT374 that is not capable of this
+ *   mode according to the manual)
  * - fold PCI clock detection and DPLL setup code into init_chipset_hpt366(),
  *   also fixing the interchanged 25/40 MHz PCI clock cases for HPT36x chips;
  *   unify HPT36x/37x timing setup code and the speedproc handlers by joining
@@ -365,7 +366,6 @@ static u32 sixty_six_base_hpt37x[] = {
 };
 
 #define HPT366_DEBUG_DRIVE_INFO         0
-#define HPT374_ALLOW_ATA133_6           1
 #define HPT371_ALLOW_ATA133_6           1
 #define HPT302_ALLOW_ATA133_6           1
 #define HPT372_ALLOW_ATA133_6           1
@@ -450,7 +450,7 @@ static struct hpt_info hpt370a __devinitdata = {
 
 static struct hpt_info hpt374 __devinitdata = {
         .chip_type      = HPT374,
-        .max_mode       = HPT374_ALLOW_ATA133_6 ? 4 : 3,
+        .max_mode       = 3,
         .dpll_clk       = 48,
         .settings       = hpt37x_settings
 };
diff --git a/drivers/ide/pci/it821x.c b/drivers/ide/pci/it821x.c
index 5faaff87d580..4bd4bf02e917 100644
--- a/drivers/ide/pci/it821x.c
+++ b/drivers/ide/pci/it821x.c
@@ -1,6 +1,6 @@
 
 /*
- * linux/drivers/ide/pci/it821x.c               Version 0.10    Mar 10 2007
+ * linux/drivers/ide/pci/it821x.c               Version 0.15    Jun 2 2007
  *
  * Copyright (C) 2004           Red Hat <alan@redhat.com>
  * Copyright (C) 2007           Bartlomiej Zolnierkiewicz
@@ -262,7 +262,7 @@ static int it821x_tunepio(ide_drive_t *drive, u8 set_pio)
         }
 
         if (itdev->smart)
-                goto set_drive_speed;
+                return 0;
 
         /* We prefer 66Mhz clock for PIO 0-3, don't care for PIO4 */
         itdev->want[unit][1] = pio_want[set_pio];
@@ -271,7 +271,6 @@ static int it821x_tunepio(ide_drive_t *drive, u8 set_pio)
         it821x_clock_strategy(drive);
         it821x_program(drive, itdev->pio[unit]);
 
-set_drive_speed:
         return ide_config_drive_speed(drive, XFER_PIO_0 + set_pio);
 }
 
@@ -455,12 +454,12 @@ static int it821x_tune_chipset (ide_drive_t *drive, byte xferspeed)
                         default:
                                 return 1;
                 }
+
+                return ide_config_drive_speed(drive, speed);
         }
-        /*
-         *      In smart mode the clocking is done by the host controller
-         *      snooping the mode we picked. The rest of it is not our problem
-         */
-        return ide_config_drive_speed(drive, speed);
+
+        /* don't touch anything in the smart mode */
+        return 0;
 }
 
 /**
@@ -559,17 +558,10 @@ static void __devinit it821x_fixups(ide_hwif_t *hwif)
                                 if(idbits[129] != 1)
                                         printk("(%dK stripe)", idbits[146]);
                                 printk(".\n");
-                        /* Now the core code will have wrongly decided no DMA
-                           so we need to fix this */
-                        hwif->dma_off_quietly(drive);
-#ifdef CONFIG_IDEDMA_ONLYDISK
-                        if (drive->media == ide_disk)
-#endif
-                                ide_set_dma(drive);
                 } else {
                         /* Non RAID volume. Fixups to stop the core code
                            doing unsupported things */
-                        id->field_valid &= 1;
+                        id->field_valid &= 3;
                         id->queue_depth = 0;
                         id->command_set_1 = 0;
                         id->command_set_2 &= 0xC400;
@@ -584,6 +576,16 @@ static void __devinit it821x_fixups(ide_hwif_t *hwif)
                         printk(KERN_INFO "%s: Performing identify fixups.\n",
                                 drive->name);
                 }
+
+                /*
+                 * Set MWDMA0 mode as enabled/support - just to tell
+                 * IDE core that DMA is supported (it821x hardware
+                 * takes care of DMA mode programming).
+                 */
+                if (id->capability & 1) {
+                        id->dma_mword |= 0x0101;
+                        drive->current_speed = XFER_MW_DMA_0;
+                }
         }
 
 }
diff --git a/drivers/ide/pci/serverworks.c b/drivers/ide/pci/serverworks.c
index 47bcd91c9b5f..d9c4fd1ae996 100644
--- a/drivers/ide/pci/serverworks.c
+++ b/drivers/ide/pci/serverworks.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/ide/pci/serverworks.c          Version 0.9     Mar 4 2007
+ * linux/drivers/ide/pci/serverworks.c          Version 0.11    Jun 2 2007
  *
  * Copyright (C) 1998-2000 Michel Aubry
  * Copyright (C) 1998-2000 Andrzej Krzysztofowicz
@@ -170,42 +170,55 @@ static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                 if (!drive->init_speed) {
                         u8 dma_stat = inb(hwif->dma_status);
 
-dma_pio:
                         if (((ultra_enable << (7-drive->dn) & 0x80) == 0x80) &&
                             ((dma_stat & (1<<(5+unit))) == (1<<(5+unit)))) {
                                 drive->current_speed = drive->init_speed = XFER_UDMA_0 + udma_modes[(ultra_timing >> (4*unit)) & ~(0xF0)];
                                 return 0;
                         } else if ((dma_timing) &&
                                    ((dma_stat&(1<<(5+unit)))==(1<<(5+unit)))) {
-                                u8 dmaspeed = dma_timing;
+                                u8 dmaspeed;
 
-                                dma_timing &= ~0xFFU;
-                                if ((dmaspeed & 0x20) == 0x20)
+                                switch (dma_timing & 0x77) {
+                                case 0x20:
                                         dmaspeed = XFER_MW_DMA_2;
-                                else if ((dmaspeed & 0x21) == 0x21)
+                                        break;
+                                case 0x21:
                                         dmaspeed = XFER_MW_DMA_1;
-                                else if ((dmaspeed & 0x77) == 0x77)
+                                        break;
+                                case 0x77:
                                         dmaspeed = XFER_MW_DMA_0;
-                                else
+                                        break;
+                                default:
                                         goto dma_pio;
+                                }
+
                                 drive->current_speed = drive->init_speed = dmaspeed;
                                 return 0;
-                        } else if (pio_timing) {
-                                u8 piospeed = pio_timing;
+                        }
+dma_pio:
+                        if (pio_timing) {
+                                u8 piospeed;
 
-                                pio_timing &= ~0xFFU;
-                                if ((piospeed & 0x20) == 0x20)
+                                switch (pio_timing & 0x7f) {
+                                case 0x20:
                                         piospeed = XFER_PIO_4;
-                                else if ((piospeed & 0x22) == 0x22)
+                                        break;
+                                case 0x22:
                                         piospeed = XFER_PIO_3;
-                                else if ((piospeed & 0x34) == 0x34)
+                                        break;
+                                case 0x34:
                                         piospeed = XFER_PIO_2;
-                                else if ((piospeed & 0x47) == 0x47)
+                                        break;
+                                case 0x47:
                                         piospeed = XFER_PIO_1;
-                                else if ((piospeed & 0x5d) == 0x5d)
+                                        break;
+                                case 0x5d:
                                         piospeed = XFER_PIO_0;
-                                else
+                                        break;
+                                default:
                                         goto oem_setup_failed;
+                                }
+
                                 drive->current_speed = drive->init_speed = piospeed;
                                 return 0;
                         }
@@ -214,8 +227,8 @@ dma_pio:
 
 oem_setup_failed:
 
-        pio_timing      &= ~0xFFU;
-        dma_timing      &= ~0xFFU;
+        pio_timing      = 0;
+        dma_timing      = 0;
         ultra_timing    &= ~(0x0F << (4*unit));
         ultra_enable    &= ~(0x01 << drive->dn);
         csb5_pio        &= ~(0x0F << (4*drive->dn));
diff --git a/drivers/infiniband/hw/amso1100/c2.c b/drivers/infiniband/hw/amso1100/c2.c
index 58bc272bd407..0aecea67f3e6 100644
--- a/drivers/infiniband/hw/amso1100/c2.c
+++ b/drivers/infiniband/hw/amso1100/c2.c
@@ -672,7 +672,7 @@ static int c2_up(struct net_device *netdev)
          * rdma interface.
          */
         in_dev = in_dev_get(netdev);
-        in_dev->cnf.arp_ignore = 1;
+        IN_DEV_CONF_SET(in_dev, ARP_IGNORE, 1);
         in_dev_put(in_dev);
 
         return 0;
diff --git a/drivers/input/keyboard/pxa27x_keyboard.c b/drivers/input/keyboard/pxa27x_keyboard.c
index 06eaf766d9d2..f9e82c9ca421 100644
--- a/drivers/input/keyboard/pxa27x_keyboard.c
+++ b/drivers/input/keyboard/pxa27x_keyboard.c
@@ -104,7 +104,7 @@ static int pxakbd_open(struct input_dev *dev)
         KPREC = 0x7F;
 
         /* Enable unit clock */
-        pxa_set_cken(CKEN19_KEYPAD, 1);
+        pxa_set_cken(CKEN_KEYPAD, 1);
 
         return 0;
 }
@@ -112,7 +112,7 @@ static int pxakbd_open(struct input_dev *dev)
 static void pxakbd_close(struct input_dev *dev)
 {
         /* Disable clock unit */
-        pxa_set_cken(CKEN19_KEYPAD, 0);
+        pxa_set_cken(CKEN_KEYPAD, 0);
 }
 
 #ifdef CONFIG_PM
@@ -185,7 +185,7 @@ static int __devinit pxakbd_probe(struct platform_device *pdev)
                             DRIVER_NAME, pdev);
         if (error) {
                 printk(KERN_ERR "Cannot request keypad IRQ\n");
-                pxa_set_cken(CKEN19_KEYPAD, 0);
+                pxa_set_cken(CKEN_KEYPAD, 0);
                 goto err_free_dev;
         }
 
diff --git a/drivers/isdn/hardware/eicon/divasfunc.c b/drivers/isdn/hardware/eicon/divasfunc.c
index 46fc21a3f8ff..d36a4c09e25d 100644
--- a/drivers/isdn/hardware/eicon/divasfunc.c
+++ b/drivers/isdn/hardware/eicon/divasfunc.c
@@ -195,7 +195,7 @@ static int DIVA_INIT_FUNCTION connect_didd(void)
 /*
  * disconnect from didd
  */
-static void DIVA_EXIT_FUNCTION disconnect_didd(void)
+static void disconnect_didd(void)
 {
         IDI_SYNC_REQ req;
 
diff --git a/drivers/media/common/Kconfig b/drivers/media/common/Kconfig
index c120114c241b..5c63c8e24ee7 100644
--- a/drivers/media/common/Kconfig
+++ b/drivers/media/common/Kconfig
@@ -4,5 +4,6 @@ config VIDEO_SAA7146
 
 config VIDEO_SAA7146_VV
         tristate
+        depends on VIDEO_DEV
         select VIDEO_BUF
         select VIDEO_SAA7146
diff --git a/drivers/media/dvb/b2c2/Makefile b/drivers/media/dvb/b2c2/Makefile
index 1a1c3bca55fa..bff00b58bf65 100644
--- a/drivers/media/dvb/b2c2/Makefile
+++ b/drivers/media/dvb/b2c2/Makefile
@@ -1,8 +1,11 @@
 b2c2-flexcop-objs = flexcop.o flexcop-fe-tuner.o flexcop-i2c.o \
-        flexcop-sram.o flexcop-eeprom.o flexcop-misc.o flexcop-hw-filter.o \
-        flexcop-dma.o
+        flexcop-sram.o flexcop-eeprom.o flexcop-misc.o flexcop-hw-filter.o
 obj-$(CONFIG_DVB_B2C2_FLEXCOP) += b2c2-flexcop.o
 
+ifneq ($(CONFIG_DVB_B2C2_FLEXCOP_PCI),)
+b2c2-flexcop-objs += flexcop-dma.o
+endif
+
 b2c2-flexcop-pci-objs = flexcop-pci.o
 obj-$(CONFIG_DVB_B2C2_FLEXCOP_PCI) += b2c2-flexcop-pci.o
 
diff --git a/drivers/media/dvb/cinergyT2/cinergyT2.c b/drivers/media/dvb/cinergyT2/cinergyT2.c
index 34d7abc900d7..6aba5b39ed14 100644
--- a/drivers/media/dvb/cinergyT2/cinergyT2.c
+++ b/drivers/media/dvb/cinergyT2/cinergyT2.c
@@ -519,8 +519,7 @@ static int cinergyt2_release (struct inode *inode, struct file *file)
         struct dvb_device *dvbdev = file->private_data;
         struct cinergyt2 *cinergyt2 = dvbdev->priv;
 
-        if (mutex_lock_interruptible(&cinergyt2->sem))
-                return -ERESTARTSYS;
+        mutex_lock(&cinergyt2->sem);
 
         if (!cinergyt2->disconnect_pending && (file->f_flags & O_ACCMODE) != O_RDONLY) {
                 cancel_delayed_work(&cinergyt2->query_work);
diff --git a/drivers/media/dvb/frontends/tda10086.c b/drivers/media/dvb/frontends/tda10086.c
index ccc429cbbad0..0f2d4b415560 100644
--- a/drivers/media/dvb/frontends/tda10086.c
+++ b/drivers/media/dvb/frontends/tda10086.c
@@ -41,6 +41,7 @@ struct tda10086_state {
         /* private demod data */
         u32 frequency;
         u32 symbol_rate;
+        bool has_lock;
 };
 
 static int debug = 0;
@@ -116,7 +117,7 @@ static int tda10086_init(struct dvb_frontend* fe)
         // misc setup
         tda10086_write_byte(state, 0x01, 0x94);
         tda10086_write_byte(state, 0x02, 0x35); // NOTE: TT drivers appear to disable CSWP
-        tda10086_write_byte(state, 0x03, 0x64);
+        tda10086_write_byte(state, 0x03, 0xe4);
         tda10086_write_byte(state, 0x04, 0x43);
         tda10086_write_byte(state, 0x0c, 0x0c);
         tda10086_write_byte(state, 0x1b, 0xb0); // noise threshold
@@ -146,7 +147,7 @@ static int tda10086_init(struct dvb_frontend* fe)
         // setup AGC
         tda10086_write_byte(state, 0x05, 0x0B);
         tda10086_write_byte(state, 0x37, 0x63);
-        tda10086_write_byte(state, 0x3f, 0x03); // NOTE: flydvb uses 0x0a and varies it
+        tda10086_write_byte(state, 0x3f, 0x0a); // NOTE: flydvb varies it
         tda10086_write_byte(state, 0x40, 0x64);
         tda10086_write_byte(state, 0x41, 0x4f);
         tda10086_write_byte(state, 0x42, 0x43);
@@ -398,6 +399,10 @@ static int tda10086_set_frontend(struct dvb_frontend* fe,
 
         dprintk ("%s\n", __FUNCTION__);
 
+        // modify parameters for tuning
+        tda10086_write_byte(state, 0x02, 0x35);
+        state->has_lock = false;
+
         // set params
         if (fe->ops.tuner_ops.set_params) {
                 fe->ops.tuner_ops.set_params(fe, fe_params);
@@ -542,8 +547,14 @@ static int tda10086_read_status(struct dvb_frontend* fe, fe_status_t *fe_status)
                 *fe_status |= FE_HAS_VITERBI;
         if (val & 0x08)
                 *fe_status |= FE_HAS_SYNC;
-        if (val & 0x10)
+        if (val & 0x10) {
                 *fe_status |= FE_HAS_LOCK;
+                if (!state->has_lock) {
+                        state->has_lock = true;
+                        // modify parameters for stable reception
+                        tda10086_write_byte(state, 0x02, 0x00);
+                }
+        }
 
         return 0;
 }
@@ -555,7 +566,7 @@ static int tda10086_read_signal_strength(struct dvb_frontend* fe, u16 * signal)
 
         dprintk ("%s\n", __FUNCTION__);
 
-        _str = tda10086_read_byte(state, 0x43);
+        _str = 0xff - tda10086_read_byte(state, 0x43);
         *signal = (_str << 8) | _str;
 
         return 0;
@@ -568,7 +579,7 @@ static int tda10086_read_snr(struct dvb_frontend* fe, u16 * snr)
 
         dprintk ("%s\n", __FUNCTION__);
 
-        _snr = tda10086_read_byte(state, 0x1c);
+        _snr = 0xff - tda10086_read_byte(state, 0x1c);
         *snr = (_snr << 8) | _snr;
 
         return 0;
diff --git a/drivers/media/dvb/frontends/tda826x.c b/drivers/media/dvb/frontends/tda826x.c
index 79f971dc52b6..bd3ebc284835 100644
--- a/drivers/media/dvb/frontends/tda826x.c
+++ b/drivers/media/dvb/frontends/tda826x.c
@@ -89,8 +89,8 @@ static int tda826x_set_params(struct dvb_frontend *fe, struct dvb_frontend_param
         buf[2] = (1<<5) | 0x0b; // 1Mhz + 0.45 VCO
         buf[3] = div >> 7;
         buf[4] = div << 1;
-        buf[5] = 0xff; // basedband filter to max
-        buf[6] = 0xfe; // gains at max + no RF attenuation
+        buf[5] = 0x77; // baseband cut-off 19 MHz
+        buf[6] = 0xfe; // baseband gain 9 db + no RF attenuation
         buf[7] = 0x83; // charge pumps at high, tests off
         buf[8] = 0x80; // recommended value 4 for AMPVCO + disable ports.
         buf[9] = 0x1a; // normal caltime + recommended values for SELTH + SELVTL
diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 5cb3f54b548b..4cca55170e21 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -347,7 +347,7 @@ endmenu # encoder / decoder chips
 
 config VIDEO_VIVI
         tristate "Virtual Video Driver"
-        depends on VIDEO_V4L2 && !SPARC32 && !SPARC64 && PCI
+        depends on VIDEO_V4L2 && !SPARC32 && !SPARC64 && PCI && VIDEO_DEV
         select VIDEO_BUF
         default n
         ---help---
diff --git a/drivers/media/video/ivtv/ivtv-cards.h b/drivers/media/video/ivtv/ivtv-cards.h
index 15012f88b802..91e9e90c14a5 100644
--- a/drivers/media/video/ivtv/ivtv-cards.h
+++ b/drivers/media/video/ivtv/ivtv-cards.h
@@ -86,7 +86,7 @@
                           V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE | \
                           V4L2_CAP_SLICED_VBI_CAPTURE)
 #define IVTV_CAP_DECODER (V4L2_CAP_VBI_OUTPUT | V4L2_CAP_VIDEO_OUTPUT | \
-                          V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_VIDEO_OUTPUT_OVERLAY | V4L2_CAP_VIDEO_OUTPUT_POS)
+                          V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_VIDEO_OUTPUT_OVERLAY)
 
 struct ivtv_card_video_input {
         u8  video_type;         /* video input type */
diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index e29f949adf57..efc66355339a 100644
--- a/drivers/media/video/ivtv/ivtv-driver.c
+++ b/drivers/media/video/ivtv/ivtv-driver.c
@@ -652,6 +652,7 @@ static int __devinit ivtv_init_struct1(struct ivtv *itv)
         itv->dma_timer.data = (unsigned long)itv;
 
         itv->cur_dma_stream = -1;
+        itv->cur_pio_stream = -1;
         itv->audio_stereo_mode = AUDIO_STEREO;
         itv->audio_bilingual_mode = AUDIO_MONO_LEFT;
 
diff --git a/drivers/media/video/ivtv/ivtv-driver.h b/drivers/media/video/ivtv/ivtv-driver.h
index 552f04511ead..e6e56f175f3f 100644
--- a/drivers/media/video/ivtv/ivtv-driver.h
+++ b/drivers/media/video/ivtv/ivtv-driver.h
@@ -237,6 +237,7 @@ extern const u32 yuv_offset[4];
 #define IVTV_IRQ_ENC_VBI_CAP            (0x1 << 29)
 #define IVTV_IRQ_ENC_VIM_RST            (0x1 << 28)
 #define IVTV_IRQ_ENC_DMA_COMPLETE       (0x1 << 27)
+#define IVTV_IRQ_ENC_PIO_COMPLETE       (0x1 << 25)
 #define IVTV_IRQ_DEC_AUD_MODE_CHG       (0x1 << 24)
 #define IVTV_IRQ_DEC_DATA_REQ           (0x1 << 22)
 #define IVTV_IRQ_DEC_DMA_COMPLETE       (0x1 << 20)
@@ -247,7 +248,8 @@ extern const u32 yuv_offset[4];
 #define IVTV_IRQ_DEC_VSYNC              (0x1 << 10)
 
 /* IRQ Masks */
-#define IVTV_IRQ_MASK_INIT (IVTV_IRQ_DMA_ERR|IVTV_IRQ_ENC_DMA_COMPLETE|IVTV_IRQ_DMA_READ)
+#define IVTV_IRQ_MASK_INIT (IVTV_IRQ_DMA_ERR|IVTV_IRQ_ENC_DMA_COMPLETE|\
+                IVTV_IRQ_DMA_READ|IVTV_IRQ_ENC_PIO_COMPLETE)
 
 #define IVTV_IRQ_MASK_CAPTURE (IVTV_IRQ_ENC_START_CAP | IVTV_IRQ_ENC_EOS)
 #define IVTV_IRQ_MASK_DECODE  (IVTV_IRQ_DEC_DATA_REQ|IVTV_IRQ_DEC_AUD_MODE_CHG)
@@ -374,6 +376,9 @@ struct ivtv_mailbox_data {
 #define IVTV_F_S_STREAMOFF      7       /* signal end of stream EOS */
 #define IVTV_F_S_APPL_IO        8       /* this stream is used read/written by an application */
 
+#define IVTV_F_S_PIO_PENDING    9       /* this stream has pending PIO */
+#define IVTV_F_S_PIO_HAS_VBI    1       /* the current PIO request also requests VBI data */
+
 /* per-ivtv, i_flags */
 #define IVTV_F_I_DMA               0    /* DMA in progress */
 #define IVTV_F_I_UDMA              1    /* UDMA in progress */
@@ -390,8 +395,11 @@ struct ivtv_mailbox_data {
 #define IVTV_F_I_DECODING_YUV      12   /* this stream is YUV frame decoding */
 #define IVTV_F_I_ENC_PAUSED        13   /* the encoder is paused */
 #define IVTV_F_I_VALID_DEC_TIMINGS 14   /* last_dec_timing is valid */
-#define IVTV_F_I_WORK_HANDLER_VBI  15   /* there is work to be done for VBI */
-#define IVTV_F_I_WORK_HANDLER_YUV  16   /* there is work to be done for YUV */
+#define IVTV_F_I_HAVE_WORK         15   /* Used in the interrupt handler: there is work to be done */
+#define IVTV_F_I_WORK_HANDLER_VBI  16   /* there is work to be done for VBI */
+#define IVTV_F_I_WORK_HANDLER_YUV  17   /* there is work to be done for YUV */
+#define IVTV_F_I_WORK_HANDLER_PIO  18   /* there is work to be done for PIO */
+#define IVTV_F_I_PIO               19   /* PIO in progress */
 
 /* Event notifications */
 #define IVTV_F_I_EV_DEC_STOPPED    28   /* decoder stopped event */
@@ -484,6 +492,7 @@ struct ivtv_stream {
 
         /* Base Dev SG Array for cx23415/6 */
         struct ivtv_SG_element *SGarray;
+        struct ivtv_SG_element *PIOarray;
         dma_addr_t SG_handle;
         int SG_length;
 
@@ -706,6 +715,7 @@ struct ivtv {
         atomic_t decoding;      /* count number of active decoding streams */
         u32 irq_rr_idx; /* Round-robin stream index */
         int cur_dma_stream;     /* index of stream doing DMA */
+        int cur_pio_stream;     /* index of stream doing PIO */
         u32 dma_data_req_offset;
         u32 dma_data_req_size;
         int output_mode;        /* NONE, MPG, YUV, UDMA YUV, passthrough */
diff --git a/drivers/media/video/ivtv/ivtv-fileops.c b/drivers/media/video/ivtv/ivtv-fileops.c
index 8976487a65f3..555d5e6369c3 100644
--- a/drivers/media/video/ivtv/ivtv-fileops.c
+++ b/drivers/media/video/ivtv/ivtv-fileops.c
@@ -32,6 +32,8 @@
 #include "ivtv-yuv.h"
 #include "ivtv-controls.h"
 #include "ivtv-ioctl.h"
+#include "ivtv-cards.h"
+#include <media/saa7115.h>
 
 /* This function tries to claim the stream for a specific file descriptor.
    If no one else is using this stream then the stream is claimed and
@@ -786,6 +788,13 @@ int ivtv_v4l2_close(struct inode *inode, struct file *filp)
                 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
                 /* Select correct audio input (i.e. TV tuner or Line in) */
                 ivtv_audio_set_io(itv);
+                if (itv->hw_flags & IVTV_HW_SAA711X)
+                {
+                        struct v4l2_crystal_freq crystal_freq;
+                        crystal_freq.freq = SAA7115_FREQ_32_11_MHZ;
+                        crystal_freq.flags = 0;
+                        ivtv_saa7115(itv, VIDIOC_INT_S_CRYSTAL_FREQ, &crystal_freq);
+                }
                 /* Done! Unmute and continue. */
                 ivtv_unmute(itv);
                 ivtv_release_stream(s);
@@ -872,6 +881,13 @@ int ivtv_v4l2_open(struct inode *inode, struct file *filp)
                 set_bit(IVTV_F_I_RADIO_USER, &itv->i_flags);
                 /* Select the correct audio input (i.e. radio tuner) */
                 ivtv_audio_set_io(itv);
+                if (itv->hw_flags & IVTV_HW_SAA711X)
+                {
+                        struct v4l2_crystal_freq crystal_freq;
+                        crystal_freq.freq = SAA7115_FREQ_32_11_MHZ;
+                        crystal_freq.flags = SAA7115_FREQ_FL_APLL;
+                        ivtv_saa7115(itv, VIDIOC_INT_S_CRYSTAL_FREQ, &crystal_freq);
+                }
                 /* Done! Unmute and continue. */
                 ivtv_unmute(itv);
         }
diff --git a/drivers/media/video/ivtv/ivtv-ioctl.c b/drivers/media/video/ivtv/ivtv-ioctl.c
index 1989ec1cb973..57af1762de1f 100644
--- a/drivers/media/video/ivtv/ivtv-ioctl.c
+++ b/drivers/media/video/ivtv/ivtv-ioctl.c
@@ -532,11 +532,6 @@ static int ivtv_try_or_set_fmt(struct ivtv *itv, int streamtype,
                                 itv->yuv_info.yuv_forced_update = 1;
                                 return 0;
                         }
-                        if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
-                                 r.width, r.height, r.left, r.top))
-                                itv->main_rect = r;
-                        else
-                                return -EINVAL;
                 }
                 return 0;
         }
@@ -799,9 +794,39 @@ int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void
                 return ivtv_get_fmt(itv, id->type, fmt);
         }
 
+        case VIDIOC_CROPCAP: {
+                struct v4l2_cropcap *cropcap = arg;
+
+                if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
+                    cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
+                        return -EINVAL;
+                cropcap->bounds.top = cropcap->bounds.left = 0;
+                cropcap->bounds.width = 720;
+                if (cropcap->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                        cropcap->bounds.height = itv->is_50hz ? 576 : 480;
+                        cropcap->pixelaspect.numerator = itv->is_50hz ? 59 : 10;
+                        cropcap->pixelaspect.denominator = itv->is_50hz ? 54 : 11;
+                } else {
+                        cropcap->bounds.height = itv->is_out_50hz ? 576 : 480;
+                        cropcap->pixelaspect.numerator = itv->is_out_50hz ? 59 : 10;
+                        cropcap->pixelaspect.denominator = itv->is_out_50hz ? 54 : 11;
+                }
+                cropcap->defrect = cropcap->bounds;
+                return 0;
+        }
+
         case VIDIOC_S_CROP: {
                 struct v4l2_crop *crop = arg;
 
+                if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
+                    (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
+                        if (!ivtv_vapi(itv, CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, 4,
+                                 crop->c.width, crop->c.height, crop->c.left, crop->c.top)) {
+                                itv->main_rect = crop->c;
+                                return 0;
+                        }
+                        return -EINVAL;
+                }
                 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                         return -EINVAL;
                 return itv->video_dec_func(itv, VIDIOC_S_CROP, arg);
@@ -810,6 +835,11 @@ int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void
         case VIDIOC_G_CROP: {
                 struct v4l2_crop *crop = arg;
 
+                if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
+                    (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
+                        crop->c = itv->main_rect;
+                        return 0;
+                }
                 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                         return -EINVAL;
                 return itv->video_dec_func(itv, VIDIOC_G_CROP, arg);
@@ -977,7 +1007,7 @@ int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void
                 if (itv->hw_flags & IVTV_HW_CX25840) {
                         itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
                 }
-                IVTV_DEBUG_INFO("Switching standard to %llx.\n", itv->std);
+                IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
 
                 /* Tuner */
                 ivtv_call_i2c_clients(itv, VIDIOC_S_STD, &itv->std);
@@ -1207,7 +1237,7 @@ int ivtv_v4l2_ioctls(struct ivtv *itv, struct file *filp, unsigned int cmd, void
                                         (s->buffers - s->q_free.buffers) * 100 / s->buffers,
                                         (s->buffers * s->buf_size) / 1024, s->buffers);
                 }
-                IVTV_INFO("Read MPEG/VBI: %lld/%lld bytes\n", itv->mpg_data_received, itv->vbi_data_inserted);
+                IVTV_INFO("Read MPEG/VBI: %lld/%lld bytes\n", (long long)itv->mpg_data_received, (long long)itv->vbi_data_inserted);
                 IVTV_INFO("==================  END STATUS CARD #%d  ==================\n", itv->num);
                 break;
         }
@@ -1455,6 +1485,7 @@ static int ivtv_v4l2_do_ioctl(struct inode *inode, struct file *filp,
         case VIDIOC_S_FMT:
         case VIDIOC_TRY_FMT:
         case VIDIOC_ENUM_FMT:
+        case VIDIOC_CROPCAP:
         case VIDIOC_G_CROP:
         case VIDIOC_S_CROP:
         case VIDIOC_G_FREQUENCY:
diff --git a/drivers/media/video/ivtv/ivtv-irq.c b/drivers/media/video/ivtv/ivtv-irq.c
index c3a047b381b3..ba98bf054f2e 100644
--- a/drivers/media/video/ivtv/ivtv-irq.c
+++ b/drivers/media/video/ivtv/ivtv-irq.c
@@ -31,8 +31,6 @@
 
 #define DMA_MAGIC_COOKIE 0x000001fe
 
-#define SLICED_VBI_PIO 1
-
 static void ivtv_dma_dec_start(struct ivtv_stream *s);
 
 static const int ivtv_stream_map[] = {
@@ -42,12 +40,40 @@ static const int ivtv_stream_map[] = {
         IVTV_ENC_STREAM_TYPE_VBI,
 };
 
-static inline int ivtv_use_pio(struct ivtv_stream *s)
+
+static void ivtv_pio_work_handler(struct ivtv *itv)
 {
-        struct ivtv *itv = s->itv;
+        struct ivtv_stream *s = &itv->streams[itv->cur_pio_stream];
+        struct ivtv_buffer *buf;
+        struct list_head *p;
+        int i = 0;
+
+        IVTV_DEBUG_DMA("ivtv_pio_work_handler\n");
+        if (itv->cur_pio_stream < 0 || itv->cur_pio_stream >= IVTV_MAX_STREAMS ||
+                        s->v4l2dev == NULL || !ivtv_use_pio(s)) {
+                itv->cur_pio_stream = -1;
+                /* trigger PIO complete user interrupt */
+                write_reg(IVTV_IRQ_ENC_PIO_COMPLETE, 0x44);
+                return;
+        }
+        IVTV_DEBUG_DMA("Process PIO %s\n", s->name);
+        buf = list_entry(s->q_dma.list.next, struct ivtv_buffer, list);
+        list_for_each(p, &s->q_dma.list) {
+                struct ivtv_buffer *buf = list_entry(p, struct ivtv_buffer, list);
+                u32 size = s->PIOarray[i].size & 0x3ffff;
 
-        return s->dma == PCI_DMA_NONE ||
-            (SLICED_VBI_PIO && s->type == IVTV_ENC_STREAM_TYPE_VBI && itv->vbi.sliced_in->service_set);
+                /* Copy the data from the card to the buffer */
+                if (s->type == IVTV_DEC_STREAM_TYPE_VBI) {
+                        memcpy_fromio(buf->buf, itv->dec_mem + s->PIOarray[i].src - IVTV_DECODER_OFFSET, size);
+                }
+                else {
+                        memcpy_fromio(buf->buf, itv->enc_mem + s->PIOarray[i].src, size);
+                }
+                if (s->PIOarray[i].size & 0x80000000)
+                        break;
+                i++;
+        }
+        write_reg(IVTV_IRQ_ENC_PIO_COMPLETE, 0x44);
 }
 
 void ivtv_irq_work_handler(struct work_struct *work)
@@ -56,8 +82,11 @@ void ivtv_irq_work_handler(struct work_struct *work)
 
         DEFINE_WAIT(wait);
 
+        if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_PIO, &itv->i_flags))
+                ivtv_pio_work_handler(itv);
+
         if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_VBI, &itv->i_flags))
-                vbi_work_handler(itv);
+                ivtv_vbi_work_handler(itv);
 
         if (test_and_clear_bit(IVTV_F_I_WORK_HANDLER_YUV, &itv->i_flags))
                 ivtv_yuv_work_handler(itv);
@@ -173,8 +202,7 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
         }
         s->buffers_stolen = rc;
 
-        /* got the buffers, now fill in SGarray (DMA) or copy the data from the card
-           to the buffers (PIO). */
+        /* got the buffers, now fill in SGarray (DMA) */
         buf = list_entry(s->q_predma.list.next, struct ivtv_buffer, list);
         memset(buf->buf, 0, 128);
         list_for_each(p, &s->q_predma.list) {
@@ -182,21 +210,11 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
 
                 if (skip_bufs-- > 0)
                         continue;
-                if (!ivtv_use_pio(s)) {
-                        s->SGarray[idx].dst = cpu_to_le32(buf->dma_handle);
-                        s->SGarray[idx].src = cpu_to_le32(offset);
-                        s->SGarray[idx].size = cpu_to_le32(s->buf_size);
-                }
+                s->SGarray[idx].dst = cpu_to_le32(buf->dma_handle);
+                s->SGarray[idx].src = cpu_to_le32(offset);
+                s->SGarray[idx].size = cpu_to_le32(s->buf_size);
                 buf->bytesused = (size < s->buf_size) ? size : s->buf_size;
 
-                /* If PIO, then copy the data from the card to the buffer */
-                if (s->type == IVTV_DEC_STREAM_TYPE_VBI) {
-                        memcpy_fromio(buf->buf, itv->dec_mem + offset - IVTV_DECODER_OFFSET, buf->bytesused);
-                }
-                else if (ivtv_use_pio(s)) {
-                        memcpy_fromio(buf->buf, itv->enc_mem + offset, buf->bytesused);
-                }
-
                 s->q_predma.bytesused += buf->bytesused;
                 size -= buf->bytesused;
                 offset += s->buf_size;
@@ -224,11 +242,6 @@ static void dma_post(struct ivtv_stream *s)
         u32 *u32buf;
         int x = 0;
 
-        if (ivtv_use_pio(s)) {
-                if (s->q_predma.bytesused)
-                        ivtv_queue_move(s, &s->q_predma, NULL, &s->q_dma, s->q_predma.bytesused);
-                s->SG_length = 0;
-        }
         IVTV_DEBUG_DMA("%s %s completed (%x)\n", ivtv_use_pio(s) ? "PIO" : "DMA",
                         s->name, s->dma_offset);
         list_for_each(p, &s->q_dma.list) {
@@ -278,10 +291,14 @@ static void dma_post(struct ivtv_stream *s)
         if (buf)
                 buf->bytesused += s->dma_last_offset;
         if (buf && s->type == IVTV_DEC_STREAM_TYPE_VBI) {
-                /* Parse and Groom VBI Data */
-                s->q_dma.bytesused -= buf->bytesused;
-                ivtv_process_vbi_data(itv, buf, 0, s->type);
-                s->q_dma.bytesused += buf->bytesused;
+                list_for_each(p, &s->q_dma.list) {
+                        buf = list_entry(p, struct ivtv_buffer, list);
+
+                        /* Parse and Groom VBI Data */
+                        s->q_dma.bytesused -= buf->bytesused;
+                        ivtv_process_vbi_data(itv, buf, 0, s->type);
+                        s->q_dma.bytesused += buf->bytesused;
+                }
                 if (s->id == -1) {
                         ivtv_queue_move(s, &s->q_dma, NULL, &s->q_free, 0);
                         return;
@@ -351,10 +368,14 @@ static void ivtv_dma_enc_start(struct ivtv_stream *s)
         struct ivtv_stream *s_vbi = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
         int i;
 
+        IVTV_DEBUG_DMA("start %s for %s\n", ivtv_use_dma(s) ? "DMA" : "PIO", s->name);
+
         if (s->q_predma.bytesused)
                 ivtv_queue_move(s, &s->q_predma, NULL, &s->q_dma, s->q_predma.bytesused);
-        IVTV_DEBUG_DMA("start DMA for %s\n", s->name);
-        s->SGarray[s->SG_length - 1].size = cpu_to_le32(le32_to_cpu(s->SGarray[s->SG_length - 1].size) + 256);
+
+        if (ivtv_use_dma(s))
+                s->SGarray[s->SG_length - 1].size =
+                        cpu_to_le32(le32_to_cpu(s->SGarray[s->SG_length - 1].size) + 256);
 
         /* If this is an MPEG stream, and VBI data is also pending, then append the
            VBI DMA to the MPEG DMA and transfer both sets of data at once.
@@ -368,7 +389,8 @@ static void ivtv_dma_enc_start(struct ivtv_stream *s)
         if (s->type == IVTV_ENC_STREAM_TYPE_MPG && s_vbi->SG_length &&
                         s->SG_length + s_vbi->SG_length <= s->buffers) {
                 ivtv_queue_move(s_vbi, &s_vbi->q_predma, NULL, &s_vbi->q_dma, s_vbi->q_predma.bytesused);
-                s_vbi->SGarray[s_vbi->SG_length - 1].size = cpu_to_le32(le32_to_cpu(s_vbi->SGarray[s->SG_length - 1].size) + 256);
+                if (ivtv_use_dma(s_vbi))
+                        s_vbi->SGarray[s_vbi->SG_length - 1].size = cpu_to_le32(le32_to_cpu(s_vbi->SGarray[s->SG_length - 1].size) + 256);
                 for (i = 0; i < s_vbi->SG_length; i++) {
                         s->SGarray[s->SG_length++] = s_vbi->SGarray[i];
                 }
@@ -381,14 +403,26 @@ static void ivtv_dma_enc_start(struct ivtv_stream *s)
         /* Mark last buffer size for Interrupt flag */
         s->SGarray[s->SG_length - 1].size |= cpu_to_le32(0x80000000);
 
-        /* Sync Hardware SG List of buffers */
-        ivtv_stream_sync_for_device(s);
-        write_reg(s->SG_handle, IVTV_REG_ENCDMAADDR);
-        write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x02, IVTV_REG_DMAXFER);
-        set_bit(IVTV_F_I_DMA, &itv->i_flags);
-        itv->cur_dma_stream = s->type;
-        itv->dma_timer.expires = jiffies + HZ / 10;
-        add_timer(&itv->dma_timer);
+        if (ivtv_use_pio(s)) {
+                for (i = 0; i < s->SG_length; i++) {
+                        s->PIOarray[i].src = le32_to_cpu(s->SGarray[i].src);
+                        s->PIOarray[i].size = le32_to_cpu(s->SGarray[i].size);
+                }
+                set_bit(IVTV_F_I_WORK_HANDLER_PIO, &itv->i_flags);
+                set_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags);
+                set_bit(IVTV_F_I_PIO, &itv->i_flags);
+                itv->cur_pio_stream = s->type;
+        }
+        else {
+                /* Sync Hardware SG List of buffers */
+                ivtv_stream_sync_for_device(s);
+                write_reg(s->SG_handle, IVTV_REG_ENCDMAADDR);
+                write_reg_sync(read_reg(IVTV_REG_DMAXFER) | 0x02, IVTV_REG_DMAXFER);
+                set_bit(IVTV_F_I_DMA, &itv->i_flags);
+                itv->cur_dma_stream = s->type;
+                itv->dma_timer.expires = jiffies + HZ / 10;
+                add_timer(&itv->dma_timer);
+        }
 }
 
 static void ivtv_dma_dec_start(struct ivtv_stream *s)
@@ -489,6 +523,40 @@ static void ivtv_irq_enc_dma_complete(struct ivtv *itv)
         wake_up(&itv->dma_waitq);
 }
 
+static void ivtv_irq_enc_pio_complete(struct ivtv *itv)
+{
+        struct ivtv_stream *s;
+
+        if (itv->cur_pio_stream < 0 || itv->cur_pio_stream >= IVTV_MAX_STREAMS) {
+                itv->cur_pio_stream = -1;
+                return;
+        }
+        s = &itv->streams[itv->cur_pio_stream];
+        IVTV_DEBUG_IRQ("ENC PIO COMPLETE %s\n", s->name);
+        s->SG_length = 0;
+        clear_bit(IVTV_F_I_ENC_VBI, &itv->i_flags);
+        clear_bit(IVTV_F_I_PIO, &itv->i_flags);
+        itv->cur_pio_stream = -1;
+        dma_post(s);
+        if (s->type == IVTV_ENC_STREAM_TYPE_MPG)
+                ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, 0);
+        else if (s->type == IVTV_ENC_STREAM_TYPE_YUV)
+                ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, 1);
+        else if (s->type == IVTV_ENC_STREAM_TYPE_PCM)
+                ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, 2);
+        clear_bit(IVTV_F_I_PIO, &itv->i_flags);
+        if (test_and_clear_bit(IVTV_F_S_DMA_HAS_VBI, &s->s_flags)) {
+                u32 tmp;
+
+                s = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
+                tmp = s->dma_offset;
+                s->dma_offset = itv->vbi.dma_offset;
+                dma_post(s);
+                s->dma_offset = tmp;
+        }
+        wake_up(&itv->dma_waitq);
+}
+
 static void ivtv_irq_dma_err(struct ivtv *itv)
 {
         u32 data[CX2341X_MBOX_MAX_DATA];
@@ -532,13 +600,7 @@ static void ivtv_irq_enc_start_cap(struct ivtv *itv)
         clear_bit(IVTV_F_I_ENC_VBI, &itv->i_flags);
         s = &itv->streams[ivtv_stream_map[data[0]]];
         if (!stream_enc_dma_append(s, data)) {
-                if (ivtv_use_pio(s)) {
-                        dma_post(s);
-                        ivtv_vapi(itv, CX2341X_ENC_SCHED_DMA_TO_HOST, 3, 0, 0, data[0]);
-                }
-                else {
-                        set_bit(IVTV_F_S_DMA_PENDING, &s->s_flags);
-                }
+                set_bit(ivtv_use_pio(s) ? IVTV_F_S_PIO_PENDING : IVTV_F_S_DMA_PENDING, &s->s_flags);
         }
 }
 
@@ -551,15 +613,6 @@ static void ivtv_irq_enc_vbi_cap(struct ivtv *itv)
         IVTV_DEBUG_IRQ("ENC START VBI CAP\n");
         s = &itv->streams[IVTV_ENC_STREAM_TYPE_VBI];
 
-        if (ivtv_use_pio(s)) {
-                if (stream_enc_dma_append(s, data))
-                        return;
-                if (s->q_predma.bytesused)
-                        ivtv_queue_move(s, &s->q_predma, NULL, &s->q_dma, s->q_predma.bytesused);
-                s->SG_length = 0;
-                dma_post(s);
-                return;
-        }
         /* If more than two VBI buffers are pending, then
            clear the old ones and start with this new one.
            This can happen during transition stages when MPEG capturing is
@@ -582,11 +635,11 @@ static void ivtv_irq_enc_vbi_cap(struct ivtv *itv)
         if (!stream_enc_dma_append(s, data) &&
                         !test_bit(IVTV_F_S_STREAMING, &s_mpg->s_flags)) {
                 set_bit(IVTV_F_I_ENC_VBI, &itv->i_flags);
-                set_bit(IVTV_F_S_DMA_PENDING, &s->s_flags);
+                set_bit(ivtv_use_pio(s) ? IVTV_F_S_PIO_PENDING : IVTV_F_S_DMA_PENDING, &s->s_flags);
         }
 }
 
-static void ivtv_irq_dev_vbi_reinsert(struct ivtv *itv)
+static void ivtv_irq_dec_vbi_reinsert(struct ivtv *itv)
 {
         u32 data[CX2341X_MBOX_MAX_DATA];
         struct ivtv_stream *s = &itv->streams[IVTV_DEC_STREAM_TYPE_VBI];
@@ -594,7 +647,7 @@ static void ivtv_irq_dev_vbi_reinsert(struct ivtv *itv)
         IVTV_DEBUG_IRQ("DEC VBI REINSERT\n");
         if (test_bit(IVTV_F_S_CLAIMED, &s->s_flags) &&
                         !stream_enc_dma_append(s, data)) {
-                dma_post(s);
+                set_bit(IVTV_F_S_PIO_PENDING, &s->s_flags);
         }
 }
 
@@ -657,7 +710,6 @@ static void ivtv_irq_vsync(struct ivtv *itv)
         }
         if (frame != (itv->lastVsyncFrame & 1)) {
                 struct ivtv_stream *s = ivtv_get_output_stream(itv);
-                int work = 0;
 
                 itv->lastVsyncFrame += 1;
                 if (frame == 0) {
@@ -678,7 +730,7 @@ static void ivtv_irq_vsync(struct ivtv *itv)
                 /* Send VBI to saa7127 */
                 if (frame) {
                         set_bit(IVTV_F_I_WORK_HANDLER_VBI, &itv->i_flags);
-                        work = 1;
+                        set_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags);
                 }
 
                 /* Check if we need to update the yuv registers */
@@ -691,11 +743,9 @@ static void ivtv_irq_vsync(struct ivtv *itv)
                                 itv->yuv_info.new_frame_info[last_dma_frame].update = 0;
                                 itv->yuv_info.yuv_forced_update = 0;
                                 set_bit(IVTV_F_I_WORK_HANDLER_YUV, &itv->i_flags);
-                                work = 1;
+                                set_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags);
                         }
                 }
-                if (work)
-                        queue_work(itv->irq_work_queues, &itv->irq_work_queue);
         }
 }
 
@@ -755,6 +805,10 @@ irqreturn_t ivtv_irq_handler(int irq, void *dev_id)
                 ivtv_irq_enc_dma_complete(itv);
         }
 
+        if (combo & IVTV_IRQ_ENC_PIO_COMPLETE) {
+                ivtv_irq_enc_pio_complete(itv);
+        }
+
         if (combo & IVTV_IRQ_DMA_ERR) {
                 ivtv_irq_dma_err(itv);
         }
@@ -768,7 +822,7 @@ irqreturn_t ivtv_irq_handler(int irq, void *dev_id)
         }
 
         if (combo & IVTV_IRQ_DEC_VBI_RE_INSERT) {
-                ivtv_irq_dev_vbi_reinsert(itv);
+                ivtv_irq_dec_vbi_reinsert(itv);
         }
 
         if (combo & IVTV_IRQ_ENC_EOS) {
@@ -813,6 +867,22 @@ irqreturn_t ivtv_irq_handler(int irq, void *dev_id)
                 }
         }
 
+        if ((combo & IVTV_IRQ_DMA) && !test_bit(IVTV_F_I_PIO, &itv->i_flags)) {
+                for (i = 0; i < IVTV_MAX_STREAMS; i++) {
+                        int idx = (i + itv->irq_rr_idx++) % IVTV_MAX_STREAMS;
+                        struct ivtv_stream *s = &itv->streams[idx];
+
+                        if (!test_and_clear_bit(IVTV_F_S_PIO_PENDING, &s->s_flags))
+                                continue;
+                        if (s->type == IVTV_DEC_STREAM_TYPE_VBI || s->type < IVTV_DEC_STREAM_TYPE_MPG)
+                                ivtv_dma_enc_start(s);
+                        break;
+                }
+        }
+
+        if (test_and_clear_bit(IVTV_F_I_HAVE_WORK, &itv->i_flags))
+                queue_work(itv->irq_work_queues, &itv->irq_work_queue);
+
         spin_unlock(&itv->dma_reg_lock);
 
         /* If we've just handled a 'forced' vsync, it's safest to say it
diff --git a/drivers/media/video/ivtv/ivtv-queue.c b/drivers/media/video/ivtv/ivtv-queue.c
index ccfcef1ad91a..a04f9387f63d 100644
--- a/drivers/media/video/ivtv/ivtv-queue.c
+++ b/drivers/media/video/ivtv/ivtv-queue.c
@@ -195,14 +195,26 @@ int ivtv_stream_alloc(struct ivtv_stream *s)
                 s->dma != PCI_DMA_NONE ? "DMA " : "",
                 s->name, s->buffers, s->buf_size, s->buffers * s->buf_size / 1024);
 
-        /* Allocate DMA SG Arrays */
-        if (s->dma != PCI_DMA_NONE) {
-                s->SGarray = (struct ivtv_SG_element *)kzalloc(SGsize, GFP_KERNEL);
-                if (s->SGarray == NULL) {
-                        IVTV_ERR("Could not allocate SGarray for %s stream\n", s->name);
+        if (ivtv_might_use_pio(s)) {
+                s->PIOarray = (struct ivtv_SG_element *)kzalloc(SGsize, GFP_KERNEL);
+                if (s->PIOarray == NULL) {
+                        IVTV_ERR("Could not allocate PIOarray for %s stream\n", s->name);
                         return -ENOMEM;
                 }
-                s->SG_length = 0;
+        }
+
+        /* Allocate DMA SG Arrays */
+        s->SGarray = (struct ivtv_SG_element *)kzalloc(SGsize, GFP_KERNEL);
+        if (s->SGarray == NULL) {
+                IVTV_ERR("Could not allocate SGarray for %s stream\n", s->name);
+                if (ivtv_might_use_pio(s)) {
+                        kfree(s->PIOarray);
+                        s->PIOarray = NULL;
+                }
+                return -ENOMEM;
+        }
+        s->SG_length = 0;
+        if (ivtv_might_use_dma(s)) {
                 s->SG_handle = pci_map_single(itv->dev, s->SGarray, SGsize, s->dma);
                 ivtv_stream_sync_for_cpu(s);
         }
@@ -219,7 +231,7 @@ int ivtv_stream_alloc(struct ivtv_stream *s)
                         break;
                 }
                 INIT_LIST_HEAD(&buf->list);
-                if (s->dma != PCI_DMA_NONE) {
+                if (ivtv_might_use_dma(s)) {
                         buf->dma_handle = pci_map_single(s->itv->dev,
                                 buf->buf, s->buf_size + 256, s->dma);
                         ivtv_buf_sync_for_cpu(s, buf);
@@ -242,7 +254,7 @@ void ivtv_stream_free(struct ivtv_stream *s)
 
         /* empty q_free */
         while ((buf = ivtv_dequeue(s, &s->q_free))) {
-                if (s->dma != PCI_DMA_NONE)
+                if (ivtv_might_use_dma(s))
                         pci_unmap_single(s->itv->dev, buf->dma_handle,
                                 s->buf_size + 256, s->dma);
                 kfree(buf->buf);
@@ -256,6 +268,9 @@ void ivtv_stream_free(struct ivtv_stream *s)
                                  sizeof(struct ivtv_SG_element) * s->buffers, PCI_DMA_TODEVICE);
                         s->SG_handle = IVTV_DMA_UNMAPPED;
                 }
+                kfree(s->SGarray);
+                kfree(s->PIOarray);
+                s->PIOarray = NULL;
                 s->SGarray = NULL;
                 s->SG_length = 0;
         }
diff --git a/drivers/media/video/ivtv/ivtv-queue.h b/drivers/media/video/ivtv/ivtv-queue.h
index 903edd4b4381..2ed8d548255d 100644
--- a/drivers/media/video/ivtv/ivtv-queue.h
+++ b/drivers/media/video/ivtv/ivtv-queue.h
@@ -20,18 +20,43 @@
  */
 
 #define IVTV_DMA_UNMAPPED       ((u32) -1)
+#define SLICED_VBI_PIO 1
 
 /* ivtv_buffer utility functions */
+
+static inline int ivtv_might_use_pio(struct ivtv_stream *s)
+{
+        return s->dma == PCI_DMA_NONE || (SLICED_VBI_PIO && s->type == IVTV_ENC_STREAM_TYPE_VBI);
+}
+
+static inline int ivtv_use_pio(struct ivtv_stream *s)
+{
+        struct ivtv *itv = s->itv;
+
+        return s->dma == PCI_DMA_NONE ||
+            (SLICED_VBI_PIO && s->type == IVTV_ENC_STREAM_TYPE_VBI && itv->vbi.sliced_in->service_set);
+}
+
+static inline int ivtv_might_use_dma(struct ivtv_stream *s)
+{
+        return s->dma != PCI_DMA_NONE;
+}
+
+static inline int ivtv_use_dma(struct ivtv_stream *s)
+{
+        return !ivtv_use_pio(s);
+}
+
 static inline void ivtv_buf_sync_for_cpu(struct ivtv_stream *s, struct ivtv_buffer *buf)
 {
-        if (s->dma != PCI_DMA_NONE)
+        if (ivtv_use_dma(s))
                 pci_dma_sync_single_for_cpu(s->itv->dev, buf->dma_handle,
                                 s->buf_size + 256, s->dma);
 }
 
 static inline void ivtv_buf_sync_for_device(struct ivtv_stream *s, struct ivtv_buffer *buf)
 {
-        if (s->dma != PCI_DMA_NONE)
+        if (ivtv_use_dma(s))
                 pci_dma_sync_single_for_device(s->itv->dev, buf->dma_handle,
                                 s->buf_size + 256, s->dma);
 }
@@ -53,12 +78,14 @@ void ivtv_stream_free(struct ivtv_stream *s);
 
 static inline void ivtv_stream_sync_for_cpu(struct ivtv_stream *s)
 {
-        pci_dma_sync_single_for_cpu(s->itv->dev, s->SG_handle,
-                sizeof(struct ivtv_SG_element) * s->buffers, PCI_DMA_TODEVICE);
+        if (ivtv_use_dma(s))
+                pci_dma_sync_single_for_cpu(s->itv->dev, s->SG_handle,
+                        sizeof(struct ivtv_SG_element) * s->buffers, PCI_DMA_TODEVICE);
 }
 
 static inline void ivtv_stream_sync_for_device(struct ivtv_stream *s)
 {
-        pci_dma_sync_single_for_device(s->itv->dev, s->SG_handle,
-                sizeof(struct ivtv_SG_element) * s->buffers, PCI_DMA_TODEVICE);
+        if (ivtv_use_dma(s))
+                pci_dma_sync_single_for_device(s->itv->dev, s->SG_handle,
+                        sizeof(struct ivtv_SG_element) * s->buffers, PCI_DMA_TODEVICE);
 }
diff --git a/drivers/media/video/ivtv/ivtv-streams.c b/drivers/media/video/ivtv/ivtv-streams.c
index 01a41a844a30..6af88ae9295f 100644
--- a/drivers/media/video/ivtv/ivtv-streams.c
+++ b/drivers/media/video/ivtv/ivtv-streams.c
@@ -868,7 +868,7 @@ int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
         if (!test_bit(IVTV_F_S_STREAMING, &s->s_flags))
                 return 0;
 
-        IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", pts, flags);
+        IVTV_DEBUG_INFO("Stop Decode at %llu, flags: %x\n", (unsigned long long)pts, flags);
 
         /* Stop Decoder */
         if (!(flags & VIDEO_CMD_STOP_IMMEDIATELY) || pts) {
diff --git a/drivers/media/video/ivtv/ivtv-vbi.c b/drivers/media/video/ivtv/ivtv-vbi.c
index 5efa5a867818..3ba46e07ea1f 100644
--- a/drivers/media/video/ivtv/ivtv-vbi.c
+++ b/drivers/media/video/ivtv/ivtv-vbi.c
@@ -450,7 +450,7 @@ void ivtv_disable_vbi(struct ivtv *itv)
 }
 
 
-void vbi_work_handler(struct ivtv *itv)
+void ivtv_vbi_work_handler(struct ivtv *itv)
 {
         struct v4l2_sliced_vbi_data data;
 
diff --git a/drivers/media/video/ivtv/ivtv-vbi.h b/drivers/media/video/ivtv/ivtv-vbi.h
index cdaea697b3ec..ec211b49702c 100644
--- a/drivers/media/video/ivtv/ivtv-vbi.h
+++ b/drivers/media/video/ivtv/ivtv-vbi.h
@@ -23,4 +23,4 @@ void ivtv_process_vbi_data(struct ivtv *itv, struct ivtv_buffer *buf,
 int ivtv_used_line(struct ivtv *itv, int line, int field);
 void ivtv_disable_vbi(struct ivtv *itv);
 void ivtv_set_vbi(unsigned long arg);
-void vbi_work_handler(struct ivtv *itv);
+void ivtv_vbi_work_handler(struct ivtv *itv);
diff --git a/drivers/media/video/saa7111.c b/drivers/media/video/saa7111.c
index 74839f98b7c4..c1a392e47170 100644
--- a/drivers/media/video/saa7111.c
+++ b/drivers/media/video/saa7111.c
@@ -75,10 +75,6 @@ struct saa7111 {
         int norm;
         int input;
         int enable;
-        int bright;
-        int contrast;
-        int hue;
-        int sat;
 };
 
 #define   I2C_SAA7111        0x48
@@ -96,6 +92,17 @@ saa7111_write (struct i2c_client *client,
         return i2c_smbus_write_byte_data(client, reg, value);
 }
 
+static inline void
+saa7111_write_if_changed(struct i2c_client *client, u8 reg, u8 value)
+{
+        struct saa7111 *decoder = i2c_get_clientdata(client);
+
+        if (decoder->reg[reg] != value) {
+                decoder->reg[reg] = value;
+                i2c_smbus_write_byte_data(client, reg, value);
+        }
+}
+
 static int
 saa7111_write_block (struct i2c_client *client,
                      const u8          *data,
@@ -439,28 +446,14 @@ saa7111_command (struct i2c_client *client,
         {
                 struct video_picture *pic = arg;
 
-                if (decoder->bright != pic->brightness) {
-                        /* We want 0 to 255 we get 0-65535 */
-                        decoder->bright = pic->brightness;
-                        saa7111_write(client, 0x0a, decoder->bright >> 8);
-                }
-                if (decoder->contrast != pic->contrast) {
-                        /* We want 0 to 127 we get 0-65535 */
-                        decoder->contrast = pic->contrast;
-                        saa7111_write(client, 0x0b,
-                                      decoder->contrast >> 9);
-                }
-                if (decoder->sat != pic->colour) {
-                        /* We want 0 to 127 we get 0-65535 */
-                        decoder->sat = pic->colour;
-                        saa7111_write(client, 0x0c, decoder->sat >> 9);
-                }
-                if (decoder->hue != pic->hue) {
-                        /* We want -128 to 127 we get 0-65535 */
-                        decoder->hue = pic->hue;
-                        saa7111_write(client, 0x0d,
-                                      (decoder->hue - 32768) >> 8);
-                }
+                /* We want 0 to 255 we get 0-65535 */
+                saa7111_write_if_changed(client, 0x0a, pic->brightness >> 8);
+                /* We want 0 to 127 we get 0-65535 */
+                saa7111_write(client, 0x0b, pic->contrast >> 9);
+                /* We want 0 to 127 we get 0-65535 */
+                saa7111_write(client, 0x0c, pic->colour >> 9);
+                /* We want -128 to 127 we get 0-65535 */
+                saa7111_write(client, 0x0d, (pic->hue - 32768) >> 8);
         }
                 break;
 
@@ -524,10 +517,6 @@ saa7111_detect_client (struct i2c_adapter *adapter,
         decoder->norm = VIDEO_MODE_NTSC;
         decoder->input = 0;
         decoder->enable = 1;
-        decoder->bright = 32768;
-        decoder->contrast = 32768;
-        decoder->hue = 32768;
-        decoder->sat = 32768;
         i2c_set_clientdata(client, decoder);
 
         i = i2c_attach_client(client);
diff --git a/drivers/media/video/usbvision/usbvision-core.c b/drivers/media/video/usbvision/usbvision-core.c
index 9118a6227ea6..7df071eb0a3b 100644
--- a/drivers/media/video/usbvision/usbvision-core.c
+++ b/drivers/media/video/usbvision/usbvision-core.c
@@ -1414,6 +1414,11 @@ static void usbvision_isocIrq(struct urb *urb)
         if (!USBVISION_IS_OPERATIONAL(usbvision))
                 return;
 
+        /* any urb with wrong status is ignored without acknowledgement */
+        if (urb->status == -ENOENT) {
+                return;
+        }
+
         f = &usbvision->curFrame;
 
         /* Manage streaming interruption */
@@ -1436,18 +1441,21 @@ static void usbvision_isocIrq(struct urb *urb)
         if (usbvision->streaming == Stream_On) {
 
                 /* If we collected enough data let's parse! */
-                if (scratch_len(usbvision) > USBVISION_HEADER_LENGTH) { /* 12 == header_length */
-                        /*If we don't have a frame we're current working on, complain */
-                        if(!list_empty(&(usbvision->inqueue))) {
-                                if (!(*f)) {
-                                        (*f) = list_entry(usbvision->inqueue.next,struct usbvision_frame, frame);
-                                }
-                                usbvision_parse_data(usbvision);
-                        }
-                        else {
-                                PDEBUG(DBG_IRQ, "received data, but no one needs it");
-                                scratch_reset(usbvision);
+                if ((scratch_len(usbvision) > USBVISION_HEADER_LENGTH) &&
+                    (!list_empty(&(usbvision->inqueue))) ) {
+                        if (!(*f)) {
+                                (*f) = list_entry(usbvision->inqueue.next,
+                                                  struct usbvision_frame,
+                                                  frame);
                         }
+                        usbvision_parse_data(usbvision);
+                }
+                else {
+                        /*If we don't have a frame
+                          we're current working on, complain */
+                        PDEBUG(DBG_IRQ,
+                               "received data, but no one needs it");
+                        scratch_reset(usbvision);
                 }
         }
         else {
@@ -1466,10 +1474,10 @@ static void usbvision_isocIrq(struct urb *urb)
         urb->dev = usbvision->dev;
         errCode = usb_submit_urb (urb, GFP_ATOMIC);
 
-        /* Disable this warning.  By design of the driver. */
-        //      if(errCode) {
-        //              err("%s: usb_submit_urb failed: error %d", __FUNCTION__, errCode);
-        //      }
+        if(errCode) {
+                err("%s: usb_submit_urb failed: error %d",
+                    __FUNCTION__, errCode);
+        }
 
         return;
 }
@@ -2394,7 +2402,7 @@ int usbvision_init_isoc(struct usb_usbvision *usbvision)
 {
         struct usb_device *dev = usbvision->dev;
         int bufIdx, errCode, regValue;
-        const int sb_size = USBVISION_URB_FRAMES * USBVISION_MAX_ISOC_PACKET_SIZE;
+        int sb_size;
 
         if (!USBVISION_IS_OPERATIONAL(usbvision))
                 return -EFAULT;
@@ -2408,11 +2416,14 @@ int usbvision_init_isoc(struct usb_usbvision *usbvision)
                 usbvision->last_error = errCode;
                 return -EBUSY;
         }
+        sb_size = USBVISION_URB_FRAMES * usbvision->isocPacketSize;
 
-        regValue = (16 - usbvision_read_reg(usbvision, USBVISION_ALTER_REG)) & 0x0F;
+        regValue = (16 - usbvision_read_reg(usbvision,
+                                            USBVISION_ALTER_REG)) & 0x0F;
 
         usbvision->usb_bandwidth = regValue >> 1;
-        PDEBUG(DBG_ISOC, "USB Bandwidth Usage: %dMbit/Sec", usbvision->usb_bandwidth);
+        PDEBUG(DBG_ISOC, "USB Bandwidth Usage: %dMbit/Sec",
+               usbvision->usb_bandwidth);
 
 
 
@@ -2428,7 +2439,11 @@ int usbvision_init_isoc(struct usb_usbvision *usbvision)
                         return -ENOMEM;
                 }
                 usbvision->sbuf[bufIdx].urb = urb;
-                usbvision->sbuf[bufIdx].data = usb_buffer_alloc(usbvision->dev, sb_size, GFP_KERNEL,&urb->transfer_dma);
+                usbvision->sbuf[bufIdx].data =
+                        usb_buffer_alloc(usbvision->dev,
+                                         sb_size,
+                                         GFP_KERNEL,
+                                         &urb->transfer_dma);
                 urb->dev = dev;
                 urb->context = usbvision;
                 urb->pipe = usb_rcvisocpipe(dev, usbvision->video_endp);
@@ -2442,21 +2457,26 @@ int usbvision_init_isoc(struct usb_usbvision *usbvision)
                 for (j = k = 0; j < USBVISION_URB_FRAMES; j++,
                      k += usbvision->isocPacketSize) {
                         urb->iso_frame_desc[j].offset = k;
-                        urb->iso_frame_desc[j].length = usbvision->isocPacketSize;
+                        urb->iso_frame_desc[j].length =
+                                usbvision->isocPacketSize;
                 }
         }
 
 
         /* Submit all URBs */
         for (bufIdx = 0; bufIdx < USBVISION_NUMSBUF; bufIdx++) {
-                        errCode = usb_submit_urb(usbvision->sbuf[bufIdx].urb, GFP_KERNEL);
+                        errCode = usb_submit_urb(usbvision->sbuf[bufIdx].urb,
+                                                 GFP_KERNEL);
                 if (errCode) {
-                        err("%s: usb_submit_urb(%d) failed: error %d", __FUNCTION__, bufIdx, errCode);
+                        err("%s: usb_submit_urb(%d) failed: error %d",
+                            __FUNCTION__, bufIdx, errCode);
                 }
         }
 
         usbvision->streaming = Stream_Idle;
-        PDEBUG(DBG_ISOC, "%s: streaming=1 usbvision->video_endp=$%02x", __FUNCTION__, usbvision->video_endp);
+        PDEBUG(DBG_ISOC, "%s: streaming=1 usbvision->video_endp=$%02x",
+               __FUNCTION__,
+               usbvision->video_endp);
         return 0;
 }
 
@@ -2470,7 +2490,7 @@ int usbvision_init_isoc(struct usb_usbvision *usbvision)
 void usbvision_stop_isoc(struct usb_usbvision *usbvision)
 {
         int bufIdx, errCode, regValue;
-        const int sb_size = USBVISION_URB_FRAMES * USBVISION_MAX_ISOC_PACKET_SIZE;
+        int sb_size = USBVISION_URB_FRAMES * usbvision->isocPacketSize;
 
         if ((usbvision->streaming == Stream_Off) || (usbvision->dev == NULL))
                 return;
@@ -2499,15 +2519,19 @@ void usbvision_stop_isoc(struct usb_usbvision *usbvision)
                 errCode = usb_set_interface(usbvision->dev, usbvision->iface,
                                             usbvision->ifaceAlt);
                 if (errCode < 0) {
-                        err("%s: usb_set_interface() failed: error %d", __FUNCTION__, errCode);
+                        err("%s: usb_set_interface() failed: error %d",
+                            __FUNCTION__, errCode);
                         usbvision->last_error = errCode;
                 }
-                regValue = (16 - usbvision_read_reg(usbvision, USBVISION_ALTER_REG)) & 0x0F;
-                usbvision->isocPacketSize = (regValue == 0) ? 0 : (regValue * 64) - 1;
-                PDEBUG(DBG_ISOC, "ISO Packet Length:%d", usbvision->isocPacketSize);
+                regValue = (16-usbvision_read_reg(usbvision, USBVISION_ALTER_REG)) & 0x0F;
+                usbvision->isocPacketSize =
+                        (regValue == 0) ? 0 : (regValue * 64) - 1;
+                PDEBUG(DBG_ISOC, "ISO Packet Length:%d",
+                       usbvision->isocPacketSize);
 
                 usbvision->usb_bandwidth = regValue >> 1;
-                PDEBUG(DBG_ISOC, "USB Bandwidth Usage: %dMbit/Sec", usbvision->usb_bandwidth);
+                PDEBUG(DBG_ISOC, "USB Bandwidth Usage: %dMbit/Sec",
+                       usbvision->usb_bandwidth);
         }
 }
 
diff --git a/drivers/media/video/usbvision/usbvision.h b/drivers/media/video/usbvision/usbvision.h
index bd6f6422ed54..c759d00d7014 100644
--- a/drivers/media/video/usbvision/usbvision.h
+++ b/drivers/media/video/usbvision/usbvision.h
@@ -146,7 +146,6 @@
 #define USBVISION_CLIPMASK_SIZE         (MAX_FRAME_WIDTH * MAX_FRAME_HEIGHT / 8) //bytesize of clipmask
 
 #define USBVISION_URB_FRAMES            32
-#define USBVISION_MAX_ISOC_PACKET_SIZE  959                     // NT1003 Specs Document says 1023
 
 #define USBVISION_NUM_HEADERMARKER      20
 #define USBVISION_NUMFRAMES             3  /* Maximum number of frames an application can get */
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index c1dfd03d559a..41bfb5dfe6ff 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -15,6 +15,7 @@
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/mmc.h>
+#include <linux/mmc/sd.h>
 
 #include "core.h"
 #include "sysfs.h"
@@ -192,6 +193,16 @@ static int mmc_read_switch(struct mmc_card *card)
         int err;
         u8 *status;
 
+        if (card->scr.sda_vsn < SCR_SPEC_VER_1)
+                return MMC_ERR_NONE;
+
+        if (!(card->csd.cmdclass & CCC_SWITCH)) {
+                printk(KERN_WARNING "%s: card lacks mandatory switch "
+                        "function, performance might suffer.\n",
+                        mmc_hostname(card->host));
+                return MMC_ERR_NONE;
+        }
+
         err = MMC_ERR_FAILED;
 
         status = kmalloc(64, GFP_KERNEL);
@@ -204,10 +215,9 @@ static int mmc_read_switch(struct mmc_card *card)
 
         err = mmc_sd_switch(card, 0, 0, 1, status);
         if (err != MMC_ERR_NONE) {
-                /*
-                 * Card not supporting high-speed will ignore the
-                 * command.
-                 */
+                printk(KERN_WARNING "%s: problem reading switch "
+                        "capabilities, performance might suffer.\n",
+                        mmc_hostname(card->host));
                 err = MMC_ERR_NONE;
                 goto out;
         }
@@ -229,6 +239,12 @@ static int mmc_switch_hs(struct mmc_card *card)
         int err;
         u8 *status;
 
+        if (card->scr.sda_vsn < SCR_SPEC_VER_1)
+                return MMC_ERR_NONE;
+
+        if (!(card->csd.cmdclass & CCC_SWITCH))
+                return MMC_ERR_NONE;
+
         if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
                 return MMC_ERR_NONE;
 
@@ -402,7 +418,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         /*
          * Switch to wider bus (if supported).
          */
-        if ((host->caps && MMC_CAP_4_BIT_DATA) &&
+        if ((host->caps & MMC_CAP_4_BIT_DATA) &&
                 (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
                 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
                 if (err != MMC_ERR_NONE)
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index e37943c314cb..5b00c194b628 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -417,7 +417,7 @@ static unsigned int at91_mci_send_command(struct at91mci_host *host, struct mmc_
                 blocks = 0;
         }
 
-        if (cmd->opcode == MMC_STOP_TRANSMISSION)
+        if (host->flags & FL_SENT_STOP)
                 cmdr |= AT91_MCI_TRCMD_STOP;
 
         if (host->bus_mode == MMC_BUSMODE_OPENDRAIN)
@@ -563,8 +563,7 @@ static void at91mci_completed_command(struct at91mci_host *host)
         if (status & (AT91_MCI_RINDE | AT91_MCI_RDIRE | AT91_MCI_RCRCE |
                         AT91_MCI_RENDE | AT91_MCI_RTOE | AT91_MCI_DCRCE |
                         AT91_MCI_DTOE | AT91_MCI_OVRE | AT91_MCI_UNRE)) {
-                if ((status & AT91_MCI_RCRCE) &&
-                        ((cmd->opcode == MMC_SEND_OP_COND) || (cmd->opcode == SD_APP_OP_COND))) {
+                if ((status & AT91_MCI_RCRCE) && !(mmc_resp_type(cmd) & MMC_RSP_CRC)) {
                         cmd->error = MMC_ERR_NONE;
                 }
                 else {
diff --git a/drivers/mmc/host/au1xmmc.c b/drivers/mmc/host/au1xmmc.c
index f967226d7505..52b63f11ddd6 100644
--- a/drivers/mmc/host/au1xmmc.c
+++ b/drivers/mmc/host/au1xmmc.c
@@ -76,8 +76,7 @@ const struct {
 #endif
 };
 
-#define AU1XMMC_CONTROLLER_COUNT \
-        (sizeof(au1xmmc_card_table) / sizeof(au1xmmc_card_table[0]))
+#define AU1XMMC_CONTROLLER_COUNT (ARRAY_SIZE(au1xmmc_card_table))
 
 /* This array stores pointers for the hosts (used by the IRQ handler) */
 struct au1xmmc_host *au1xmmc_hosts[AU1XMMC_CONTROLLER_COUNT];
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index da7c3b0c533c..ce3ed67a878e 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -54,8 +54,8 @@
 
 #define DRV_MODULE_NAME         "bnx2"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "1.5.10"
-#define DRV_MODULE_RELDATE      "May 1, 2007"
+#define DRV_MODULE_VERSION      "1.5.11"
+#define DRV_MODULE_RELDATE      "June 4, 2007"
 
 #define RUN_AT(x) (jiffies + (x))
 
@@ -1778,6 +1778,15 @@ bnx2_init_5709_context(struct bnx2 *bp)
         val = BNX2_CTX_COMMAND_ENABLED | BNX2_CTX_COMMAND_MEM_INIT | (1 << 12);
         val |= (BCM_PAGE_BITS - 8) << 16;
         REG_WR(bp, BNX2_CTX_COMMAND, val);
+        for (i = 0; i < 10; i++) {
+                val = REG_RD(bp, BNX2_CTX_COMMAND);
+                if (!(val & BNX2_CTX_COMMAND_MEM_INIT))
+                        break;
+                udelay(2);
+        }
+        if (val & BNX2_CTX_COMMAND_MEM_INIT)
+                return -EBUSY;
+
         for (i = 0; i < bp->ctx_pages; i++) {
                 int j;
 
@@ -1811,6 +1820,7 @@ bnx2_init_context(struct bnx2 *bp)
         vcid = 96;
         while (vcid) {
                 u32 vcid_addr, pcid_addr, offset;
+                int i;
 
                 vcid--;
 
@@ -1831,16 +1841,20 @@ bnx2_init_context(struct bnx2 *bp)
                         pcid_addr = vcid_addr;
                 }
 
-                REG_WR(bp, BNX2_CTX_VIRT_ADDR, 0x00);
-                REG_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
+                for (i = 0; i < (CTX_SIZE / PHY_CTX_SIZE); i++) {
+                        vcid_addr += (i << PHY_CTX_SHIFT);
+                        pcid_addr += (i << PHY_CTX_SHIFT);
 
-                /* Zero out the context. */
-                for (offset = 0; offset < PHY_CTX_SIZE; offset += 4) {
-                        CTX_WR(bp, 0x00, offset, 0);
-                }
+                        REG_WR(bp, BNX2_CTX_VIRT_ADDR, 0x00);
+                        REG_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
+
+                        /* Zero out the context. */
+                        for (offset = 0; offset < PHY_CTX_SIZE; offset += 4)
+                                CTX_WR(bp, 0x00, offset, 0);
 
-                REG_WR(bp, BNX2_CTX_VIRT_ADDR, vcid_addr);
-                REG_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
+                        REG_WR(bp, BNX2_CTX_VIRT_ADDR, vcid_addr);
+                        REG_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
+                }
         }
 }
 
@@ -3691,9 +3705,11 @@ bnx2_init_chip(struct bnx2 *bp)
 
         /* Initialize context mapping and zero out the quick contexts.  The
          * context block must have already been enabled. */
-        if (CHIP_NUM(bp) == CHIP_NUM_5709)
-                bnx2_init_5709_context(bp);
-        else
+        if (CHIP_NUM(bp) == CHIP_NUM_5709) {
+                rc = bnx2_init_5709_context(bp);
+                if (rc)
+                        return rc;
+        } else
                 bnx2_init_context(bp);
 
         if ((rc = bnx2_init_cpus(bp)) != 0)
@@ -3772,7 +3788,10 @@ bnx2_init_chip(struct bnx2 *bp)
         REG_WR(bp, BNX2_HC_CMD_TICKS,
                (bp->cmd_ticks_int << 16) | bp->cmd_ticks);
 
-        REG_WR(bp, BNX2_HC_STATS_TICKS, bp->stats_ticks & 0xffff00);
+        if (CHIP_NUM(bp) == CHIP_NUM_5708)
+                REG_WR(bp, BNX2_HC_STATS_TICKS, 0);
+        else
+                REG_WR(bp, BNX2_HC_STATS_TICKS, bp->stats_ticks & 0xffff00);
         REG_WR(bp, BNX2_HC_STAT_COLLECT_TICKS, 0xbb8);  /* 3ms */
 
         if (CHIP_ID(bp) == CHIP_ID_5706_A1)
@@ -3799,6 +3818,11 @@ bnx2_init_chip(struct bnx2 *bp)
         /* Initialize the receive filter. */
         bnx2_set_rx_mode(bp->dev);
 
+        if (CHIP_NUM(bp) == CHIP_NUM_5709) {
+                val = REG_RD(bp, BNX2_MISC_NEW_CORE_CTL);
+                val |= BNX2_MISC_NEW_CORE_CTL_DMA_ENABLE;
+                REG_WR(bp, BNX2_MISC_NEW_CORE_CTL, val);
+        }
         rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT2 | BNX2_DRV_MSG_CODE_RESET,
                           0);
 
@@ -4620,6 +4644,11 @@ bnx2_timer(unsigned long data)
 
         bp->stats_blk->stat_FwRxDrop = REG_RD_IND(bp, BNX2_FW_RX_DROP_COUNT);
 
+        /* workaround occasional corrupted counters */
+        if (CHIP_NUM(bp) == CHIP_NUM_5708 && bp->stats_ticks)
+                REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd |
+                                            BNX2_HC_COMMAND_STATS_NOW);
+
         if (bp->phy_flags & PHY_SERDES_FLAG) {
                 if (CHIP_NUM(bp) == CHIP_NUM_5706)
                         bnx2_5706_serdes_timer(bp);
@@ -5417,6 +5446,10 @@ bnx2_set_coalesce(struct net_device *dev, struct ethtool_coalesce *coal)
                 0xff;
 
         bp->stats_ticks = coal->stats_block_coalesce_usecs;
+        if (CHIP_NUM(bp) == CHIP_NUM_5708) {
+                if (bp->stats_ticks != 0 && bp->stats_ticks != USEC_PER_SEC)
+                        bp->stats_ticks = USEC_PER_SEC;
+        }
         if (bp->stats_ticks > 0xffff00) bp->stats_ticks = 0xffff00;
         bp->stats_ticks &= 0xffff00;
 
diff --git a/drivers/net/bnx2.h b/drivers/net/bnx2.h
index bd6288d6350f..49a5de253b17 100644
--- a/drivers/net/bnx2.h
+++ b/drivers/net/bnx2.h
@@ -1373,6 +1373,7 @@ struct l2_fhdr {
 #define BNX2_MISC_NEW_CORE_CTL                          0x000008c8
 #define BNX2_MISC_NEW_CORE_CTL_LINK_HOLDOFF_SUCCESS      (1L<<0)
 #define BNX2_MISC_NEW_CORE_CTL_LINK_HOLDOFF_REQ          (1L<<1)
+#define BNX2_MISC_NEW_CORE_CTL_DMA_ENABLE                (1L<<16)
 #define BNX2_MISC_NEW_CORE_CTL_RESERVED_CMN              (0x3fffL<<2)
 #define BNX2_MISC_NEW_CORE_CTL_RESERVED_TC               (0xffffL<<16)
 
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 00d1255e4c12..e88da72f8304 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -167,9 +167,9 @@ static void pl010_rx_chars(struct uart_amba_port *uap)
         ignore_char:
                 status = readb(uap->port.membase + UART01x_FR);
         }
-        spin_unlock(&port->lock);
+        spin_unlock(&uap->port.lock);
         tty_flip_buffer_push(tty);
-        spin_lock(&port->lock);
+        spin_lock(&uap->port.lock);
 }
 
 static void pl010_tx_chars(struct uart_amba_port *uap)
diff --git a/drivers/tc/zs.c b/drivers/tc/zs.c
index 3524e3fc08b9..61de78a9f6ee 100644
--- a/drivers/tc/zs.c
+++ b/drivers/tc/zs.c
@@ -2182,7 +2182,7 @@ struct dec_serial_hook zs_kgdbhook = {
         .init_info      = kgdbhook_init_info,
         .rx_char        = kgdbhook_rx_char,
         .cflags         = B38400 | CS8 | CLOCAL,
-}
+};
 
 void __init zs_kgdb_hook(int tty_num)
 {
diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index 30b7bfbc985a..8bcf7fe1dd80 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -476,8 +476,6 @@ static int cxacru_start_wait_urb(struct urb *urb, struct completion *done,
         add_timer(&timer);
         wait_for_completion(done);
         status = urb->status;
-        if (status == -ECONNRESET)
-                status = -ETIMEDOUT;
         del_timer_sync(&timer);
 
         if (actual_length)
@@ -629,10 +627,22 @@ static int cxacru_card_status(struct cxacru_data *instance)
         return 0;
 }
 
+static void cxacru_remove_device_files(struct usbatm_data *usbatm_instance,
+                struct atm_dev *atm_dev)
+{
+        struct usb_interface *intf = usbatm_instance->usb_intf;
+
+        #define CXACRU_DEVICE_REMOVE_FILE(_name) \
+                device_remove_file(&intf->dev, &dev_attr_##_name);
+        CXACRU_ALL_FILES(REMOVE);
+        #undef CXACRU_DEVICE_REMOVE_FILE
+}
+
 static int cxacru_atm_start(struct usbatm_data *usbatm_instance,
                 struct atm_dev *atm_dev)
 {
         struct cxacru_data *instance = usbatm_instance->driver_data;
+        struct usb_interface *intf = usbatm_instance->usb_intf;
         /*
         struct atm_dev *atm_dev = usbatm_instance->atm_dev;
         */
@@ -649,14 +659,18 @@ static int cxacru_atm_start(struct usbatm_data *usbatm_instance,
                 return ret;
         }
 
+        #define CXACRU_DEVICE_CREATE_FILE(_name) \
+                ret = device_create_file(&intf->dev, &dev_attr_##_name); \
+                if (unlikely(ret)) \
+                        goto fail_sysfs;
+        CXACRU_ALL_FILES(CREATE);
+        #undef CXACRU_DEVICE_CREATE_FILE
+
         /* start ADSL */
         mutex_lock(&instance->adsl_state_serialize);
         ret = cxacru_cm(instance, CM_REQUEST_CHIP_ADSL_LINE_START, NULL, 0, NULL, 0);
-        if (ret < 0) {
+        if (ret < 0)
                 atm_err(usbatm_instance, "cxacru_atm_start: CHIP_ADSL_LINE_START returned %d\n", ret);
-                mutex_unlock(&instance->adsl_state_serialize);
-                return ret;
-        }
 
         /* Start status polling */
         mutex_lock(&instance->poll_state_serialize);
@@ -680,6 +694,11 @@ static int cxacru_atm_start(struct usbatm_data *usbatm_instance,
         if (start_polling)
                 cxacru_poll_status(&instance->poll_work.work);
         return 0;
+
+fail_sysfs:
+        usb_err(usbatm_instance, "cxacru_atm_start: device_create_file failed (%d)\n", ret);
+        cxacru_remove_device_files(usbatm_instance, atm_dev);
+        return ret;
 }
 
 static void cxacru_poll_status(struct work_struct *work)
@@ -1065,13 +1084,6 @@ static int cxacru_bind(struct usbatm_data *usbatm_instance,
                 goto fail;
         }
 
-        #define CXACRU_DEVICE_CREATE_FILE(_name) \
-                ret = device_create_file(&intf->dev, &dev_attr_##_name); \
-                if (unlikely(ret)) \
-                        goto fail_sysfs;
-        CXACRU_ALL_FILES(CREATE);
-        #undef CXACRU_DEVICE_CREATE_FILE
-
         usb_fill_int_urb(instance->rcv_urb,
                         usb_dev, usb_rcvintpipe(usb_dev, CXACRU_EP_CMD),
                         instance->rcv_buf, PAGE_SIZE,
@@ -1092,14 +1104,6 @@ static int cxacru_bind(struct usbatm_data *usbatm_instance,
 
         return 0;
 
- fail_sysfs:
-        dbg("cxacru_bind: device_create_file failed (%d)\n", ret);
-
-        #define CXACRU_DEVICE_REMOVE_FILE(_name) \
-                device_remove_file(&intf->dev, &dev_attr_##_name);
-        CXACRU_ALL_FILES(REMOVE);
-        #undef CXACRU_DEVICE_REVOVE_FILE
-
  fail:
         free_page((unsigned long) instance->snd_buf);
         free_page((unsigned long) instance->rcv_buf);
@@ -1146,11 +1150,6 @@ static void cxacru_unbind(struct usbatm_data *usbatm_instance,
         free_page((unsigned long) instance->snd_buf);
         free_page((unsigned long) instance->rcv_buf);
 
-        #define CXACRU_DEVICE_REMOVE_FILE(_name) \
-                device_remove_file(&intf->dev, &dev_attr_##_name);
-        CXACRU_ALL_FILES(REMOVE);
-        #undef CXACRU_DEVICE_REVOVE_FILE
-
         kfree(instance);
 
         usbatm_instance->driver_data = NULL;
@@ -1231,6 +1230,7 @@ static struct usbatm_driver cxacru_driver = {
         .heavy_init     = cxacru_heavy_init,
         .unbind         = cxacru_unbind,
         .atm_start      = cxacru_atm_start,
+        .atm_stop       = cxacru_remove_device_files,
         .bulk_in        = CXACRU_EP_DATA,
         .bulk_out       = CXACRU_EP_DATA,
         .rx_padding     = 3,
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 7b1edfe46b28..6778f9af7943 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -347,10 +347,8 @@ static int handle_bidir (struct usblp *usblp)
         if (usblp->bidir && usblp->used && !usblp->sleeping) {
                 usblp->readcount = 0;
                 usblp->readurb->dev = usblp->dev;
-                if (usb_submit_urb(usblp->readurb, GFP_KERNEL) < 0) {
-                        usblp->used = 0;
+                if (usb_submit_urb(usblp->readurb, GFP_KERNEL) < 0)
                         return -EIO;
-                }
         }
 
         return 0;
@@ -412,6 +410,7 @@ static int usblp_open(struct inode *inode, struct file *file)
         usblp->readurb->status = 0;
 
         if (handle_bidir(usblp) < 0) {
+                usblp->used = 0;
                 file->private_data = NULL;
                 retval = -EIO;
         }
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index f493fb1eaa27..346fc030c929 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -40,21 +40,25 @@ config USB_DEVICEFS
 config USB_DEVICE_CLASS
         bool "USB device class-devices (DEPRECATED)"
         depends on USB
-        default n
+        default y
         ---help---
           Userspace access to USB devices is granted by device-nodes exported
           directly from the usbdev in sysfs. Old versions of the driver
           core and udev needed additional class devices to export device nodes.
 
           These additional devices are difficult to handle in userspace, if
-          information about USB interfaces must be available. One device contains
-          the device node, the other device contains the interface data. Both
-          devices are at the same level in sysfs (siblings) and one can't access
-          the other. The device node created directly by the usbdev is the parent
-          device of the interface and therefore easily accessible from the interface
-          event.
-
-          This option provides backward compatibility if needed.
+          information about USB interfaces must be available. One device
+          contains the device node, the other device contains the interface
+          data. Both devices are at the same level in sysfs (siblings) and one
+          can't access the other. The device node created directly by the
+          usb device is the parent device of the interface and therefore
+          easily accessible from the interface event.
+
+          This option provides backward compatibility for libusb device
+          nodes (lsusb) when usbfs is not used, and the following udev rule
+          doesn't exist:
+            SUBSYSTEM=="usb", ACTION=="add", ENV{DEVTYPE}=="usb_device", \
+            NAME="bus/usb/$env{BUSNUM}/$env{DEVNUM}", MODE="0644"
 
 config USB_DYNAMIC_MINORS
         bool "Dynamic USB minor allocation (EXPERIMENTAL)"
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index 2d4fd530e5e4..dd3482328ad2 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -1,4 +1,5 @@
 #include <linux/usb.h>
+#include <linux/usb/ch9.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -49,7 +50,7 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum,
         unsigned char *buffer0 = buffer;
         struct usb_endpoint_descriptor *d;
         struct usb_host_endpoint *endpoint;
-        int n, i;
+        int n, i, j;
 
         d = (struct usb_endpoint_descriptor *) buffer;
         buffer += d->bLength;
@@ -84,6 +85,45 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum,
         memcpy(&endpoint->desc, d, n);
         INIT_LIST_HEAD(&endpoint->urb_list);
 
+        /* If the bInterval value is outside the legal range,
+         * set it to a default value: 32 ms */
+        i = 0;          /* i = min, j = max, n = default */
+        j = 255;
+        if (usb_endpoint_xfer_int(d)) {
+                i = 1;
+                switch (to_usb_device(ddev)->speed) {
+                case USB_SPEED_HIGH:
+                        n = 9;          /* 32 ms = 2^(9-1) uframes */
+                        j = 16;
+                        break;
+                default:                /* USB_SPEED_FULL or _LOW */
+                        /* For low-speed, 10 ms is the official minimum.
+                         * But some "overclocked" devices might want faster
+                         * polling so we'll allow it. */
+                        n = 32;
+                        break;
+                }
+        } else if (usb_endpoint_xfer_isoc(d)) {
+                i = 1;
+                j = 16;
+                switch (to_usb_device(ddev)->speed) {
+                case USB_SPEED_HIGH:
+                        n = 9;          /* 32 ms = 2^(9-1) uframes */
+                        break;
+                default:                /* USB_SPEED_FULL */
+                        n = 6;          /* 32 ms = 2^(6-1) frames */
+                        break;
+                }
+        }
+        if (d->bInterval < i || d->bInterval > j) {
+                dev_warn(ddev, "config %d interface %d altsetting %d "
+                    "endpoint 0x%X has an invalid bInterval %d, "
+                    "changing to %d\n",
+                    cfgno, inum, asnum,
+                    d->bEndpointAddress, d->bInterval, n);
+                endpoint->desc.bInterval = n;
+        }
+
         /* Skip over any Class Specific or Vendor Specific descriptors;
          * find the next endpoint or interface descriptor */
         endpoint->extra = buffer;
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index f28af06905a5..6042364402b8 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -132,7 +132,7 @@ ep_matches (
          * where it's an output parameter representing the full speed limit.
          * the usb spec fixes high speed bulk maxpacket at 512 bytes.
          */
-        max = 0x7ff & le16_to_cpup (&desc->wMaxPacketSize);
+        max = 0x7ff & le16_to_cpu(desc->wMaxPacketSize);
         switch (type) {
         case USB_ENDPOINT_XFER_INT:
                 /* INT:  limit 64 bytes full speed, 1024 high speed */
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index 188c74a95216..46d0e5252744 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -1369,12 +1369,12 @@ config_buf (struct dev_data *dev, u8 type, unsigned index)
                 hs = !hs;
         if (hs) {
                 dev->req->buf = dev->hs_config;
-                len = le16_to_cpup (&dev->hs_config->wTotalLength);
+                len = le16_to_cpu(dev->hs_config->wTotalLength);
         } else
 #endif
         {
                 dev->req->buf = dev->config;
-                len = le16_to_cpup (&dev->config->wTotalLength);
+                len = le16_to_cpu(dev->config->wTotalLength);
         }
         ((u8 *)dev->req->buf) [1] = type;
         return len;
@@ -1885,7 +1885,7 @@ dev_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
 
         /* full or low speed config */
         dev->config = (void *) kbuf;
-        total = le16_to_cpup (&dev->config->wTotalLength);
+        total = le16_to_cpu(dev->config->wTotalLength);
         if (!is_valid_config (dev->config) || total >= length)
                 goto fail;
         kbuf += total;
@@ -1894,7 +1894,7 @@ dev_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
         /* optional high speed config */
         if (kbuf [1] == USB_DT_CONFIG) {
                 dev->hs_config = (void *) kbuf;
-                total = le16_to_cpup (&dev->hs_config->wTotalLength);
+                total = le16_to_cpu(dev->hs_config->wTotalLength);
                 if (!is_valid_config (dev->hs_config) || total >= length)
                         goto fail;
                 kbuf += total;
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 52779c52b56d..d975ecf18e00 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -2440,9 +2440,9 @@ static void handle_stat0_irqs (struct net2280 *dev, u32 stat)
 
                 tmp = 0;
 
-#define w_value         le16_to_cpup (&u.r.wValue)
-#define w_index         le16_to_cpup (&u.r.wIndex)
-#define w_length        le16_to_cpup (&u.r.wLength)
+#define w_value         le16_to_cpu(u.r.wValue)
+#define w_index         le16_to_cpu(u.r.wIndex)
+#define w_length        le16_to_cpu(u.r.wLength)
 
                 /* ack the irq */
                 writel (1 << SETUP_PACKET_INTERRUPT, &dev->regs->irqstat0);
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index b394e63894d2..c4975a6cf777 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -1651,9 +1651,9 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
                         UDC_EP_NUM_REG = 0;
                 } while (UDC_IRQ_SRC_REG & UDC_SETUP);
 
-#define w_value         le16_to_cpup (&u.r.wValue)
-#define w_index         le16_to_cpup (&u.r.wIndex)
-#define w_length        le16_to_cpup (&u.r.wLength)
+#define w_value         le16_to_cpu(u.r.wValue)
+#define w_index         le16_to_cpu(u.r.wIndex)
+#define w_length        le16_to_cpu(u.r.wLength)
 
                 /* Delegate almost all control requests to the gadget driver,
                  * except for a handful of ch9 status/feature requests that
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index 6ec8cf1a3ccb..708657c89132 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -186,10 +186,14 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                 DEBUG("query OID %08x value, len %d:\n", OID, buf_len);
                 for (i = 0; i < buf_len; i += 16) {
                         DEBUG ("%03d: %08x %08x %08x %08x\n", i,
-                                le32_to_cpup((__le32 *)&buf[i]),
-                                le32_to_cpup((__le32 *)&buf[i + 4]),
-                                le32_to_cpup((__le32 *)&buf[i + 8]),
-                                le32_to_cpup((__le32 *)&buf[i + 12]));
+                                le32_to_cpu(get_unaligned((__le32 *)
+                                        &buf[i])),
+                                le32_to_cpu(get_unaligned((__le32 *)
+                                        &buf[i + 4])),
+                                le32_to_cpu(get_unaligned((__le32 *)
+                                        &buf[i + 8])),
+                                le32_to_cpu(get_unaligned((__le32 *)
+                                        &buf[i + 12])));
                 }
         }
 
@@ -665,7 +669,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                 break;
         case OID_PNP_QUERY_POWER:
                 DEBUG("%s: OID_PNP_QUERY_POWER D%d\n", __FUNCTION__,
-                                le32_to_cpup((__le32 *) buf) - 1);
+                                le32_to_cpu(get_unaligned((__le32 *)buf)) - 1);
                 /* only suspend is a real power state, and
                  * it can't be entered by OID_PNP_SET_POWER...
                  */
@@ -704,10 +708,14 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
                 DEBUG("set OID %08x value, len %d:\n", OID, buf_len);
                 for (i = 0; i < buf_len; i += 16) {
                         DEBUG ("%03d: %08x %08x %08x %08x\n", i,
-                                le32_to_cpup((__le32 *)&buf[i]),
-                                le32_to_cpup((__le32 *)&buf[i + 4]),
-                                le32_to_cpup((__le32 *)&buf[i + 8]),
-                                le32_to_cpup((__le32 *)&buf[i + 12]));
+                                le32_to_cpu(get_unaligned((__le32 *)
+                                        &buf[i])),
+                                le32_to_cpu(get_unaligned((__le32 *)
+                                        &buf[i + 4])),
+                                le32_to_cpu(get_unaligned((__le32 *)
+                                        &buf[i + 8])),
+                                le32_to_cpu(get_unaligned((__le32 *)
+                                        &buf[i + 12])));
                 }
         }
 
@@ -721,7 +729,8 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
                  *      PROMISCUOUS, DIRECTED,
                  *      MULTICAST, ALL_MULTICAST, BROADCAST
                  */
-                *params->filter = (u16) le32_to_cpup((__le32 *)buf);
+                *params->filter = (u16) le32_to_cpu(get_unaligned(
+                                (__le32 *)buf));
                 DEBUG("%s: OID_GEN_CURRENT_PACKET_FILTER %08x\n",
                         __FUNCTION__, *params->filter);
 
@@ -771,7 +780,7 @@ update_linkstate:
                  * resuming, Windows forces a reset, and then SET_POWER D0.
                  * FIXME ... then things go batty; Windows wedges itself.
                  */
-                i = le32_to_cpup((__force __le32 *)buf);
+                i = le32_to_cpu(get_unaligned((__le32 *)buf));
                 DEBUG("%s: OID_PNP_SET_POWER D%d\n", __FUNCTION__, i - 1);
                 switch (i) {
                 case NdisDeviceStateD0:
@@ -1058,8 +1067,8 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
                 return -ENOMEM;
 
         tmp = (__le32 *) buf;
-        MsgType   = le32_to_cpup(tmp++);
-        MsgLength = le32_to_cpup(tmp++);
+        MsgType   = le32_to_cpu(get_unaligned(tmp++));
+        MsgLength = le32_to_cpu(get_unaligned(tmp++));
 
         if (configNr >= RNDIS_MAX_CONFIGS)
                 return -ENOTSUPP;
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 216c9c9d4d6d..bb9cc595219e 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -417,6 +417,8 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
         unsigned long   flags;
 
         spin_lock_irqsave (&ohci->lock, flags);
+        if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
+                goto done;
 
         /* undocumented erratum seen on at least rev D */
         if ((ohci->flags & OHCI_QUIRK_AMD756)
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index d230ee72f9cd..54979c239c63 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -1179,8 +1179,8 @@ UNUSUAL_DEV( 0x0a17, 0x006, 0x0000, 0xffff,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
-/* These are virtual windows driver CDs, which the zd1211rw driver automatically
- * converts into a WLAN devices. */
+/* These are virtual windows driver CDs, which the zd1211rw driver
+ * automatically converts into WLAN devices. */
 UNUSUAL_DEV( 0x0ace, 0x2011, 0x0101, 0x0101,
                 "ZyXEL",
                 "G-220F USB-WLAN Install",
@@ -1193,6 +1193,14 @@ UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_DEVICE ),
 
+/* SanDisk that has a second LUN for a driver ISO, reported by
+ * Ben Collins <bcollins@ubuntu.com> */
+UNUSUAL_DEV( 0x0781, 0x5406, 0x0000, 0xffff,
+                "SanDisk",
+                "U3 Cruzer Micro driver ISO",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SINGLE_LUN ),
+
 #ifdef CONFIG_USB_STORAGE_ISD200
 UNUSUAL_DEV(  0x0bf6, 0xa001, 0x0100, 0x0110,
                 "ATI",
@@ -1271,6 +1279,15 @@ UNUSUAL_DEV( 0x0dd8, 0x1060, 0x0000, 0xffff,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
+/* Reported by Edward Chapman (taken from linux-usb mailing list)
+   Netac OnlyDisk Mini U2CV2 512MB USB 2.0 Flash Drive */
+UNUSUAL_DEV( 0x0dd8, 0xd202, 0x0000, 0x9999,
+                "Netac",
+                "USB Flash Disk",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_IGNORE_RESIDUE ),
+
+
 /* Patch by Stephan Walter <stephan.walter@epfl.ch>
  * I don't know why, but it works... */
 UNUSUAL_DEV( 0x0dda, 0x0001, 0x0012, 0x0012,