41 files changed, 461 insertions, 183 deletions

diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index cc4649577a6..6dab63bdc4c 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -1090,6 +1090,11 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         dev_priv->mm.gtt_mapping =
                 io_mapping_create_wc(dev->agp->base,
                                      dev->agp->agp_info.aper_size * 1024*1024);
+        if (dev_priv->mm.gtt_mapping == NULL) {
+                ret = -EIO;
+                goto out_rmmap;
+        }
+
         /* Set up a WC MTRR for non-PAT systems.  This is more common than
          * one would think, because the kernel disables PAT on first
          * generation Core chips because WC PAT gets overridden by a UC
@@ -1122,7 +1127,7 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         if (!I915_NEED_GFX_HWS(dev)) {
                 ret = i915_init_phys_hws(dev);
                 if (ret != 0)
-                        goto out_rmmap;
+                        goto out_iomapfree;
         }
 
         /* On the 945G/GM, the chipset reports the MSI capability on the
@@ -1161,6 +1166,8 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
 
         return 0;
 
+out_iomapfree:
+        io_mapping_free(dev_priv->mm.gtt_mapping);
 out_rmmap:
         iounmap(dev_priv->regs);
 free_priv:
diff --git a/drivers/media/dvb/b2c2/flexcop-hw-filter.c b/drivers/media/dvb/b2c2/flexcop-hw-filter.c
index b386cc66c6b..451974ba32f 100644
--- a/drivers/media/dvb/b2c2/flexcop-hw-filter.c
+++ b/drivers/media/dvb/b2c2/flexcop-hw-filter.c
@@ -192,6 +192,7 @@ int flexcop_pid_feed_control(struct flexcop_device *fc, struct dvb_demux_feed *d
 
         return 0;
 }
+EXPORT_SYMBOL(flexcop_pid_feed_control);
 
 void flexcop_hw_filter_init(struct flexcop_device *fc)
 {
diff --git a/drivers/media/dvb/b2c2/flexcop-pci.c b/drivers/media/dvb/b2c2/flexcop-pci.c
index 5b30dfc7846..76e37fd96bb 100644
--- a/drivers/media/dvb/b2c2/flexcop-pci.c
+++ b/drivers/media/dvb/b2c2/flexcop-pci.c
@@ -13,9 +13,9 @@ static int enable_pid_filtering = 1;
 module_param(enable_pid_filtering, int, 0444);
 MODULE_PARM_DESC(enable_pid_filtering, "enable hardware pid filtering: supported values: 0 (fullts), 1");
 
-static int irq_chk_intv;
+static int irq_chk_intv = 100;
 module_param(irq_chk_intv, int, 0644);
-MODULE_PARM_DESC(irq_chk_intv, "set the interval for IRQ watchdog (currently just debugging).");
+MODULE_PARM_DESC(irq_chk_intv, "set the interval for IRQ streaming watchdog.");
 
 #ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG
 #define dprintk(level,args...) \
@@ -34,7 +34,9 @@ MODULE_PARM_DESC(irq_chk_intv, "set the interval for IRQ watchdog (currently jus
 
 static int debug;
 module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "set debug level (1=info,2=regs,4=TS,8=irqdma (|-able))." DEBSTATUS);
+MODULE_PARM_DESC(debug,
+        "set debug level (1=info,2=regs,4=TS,8=irqdma,16=check (|-able))."
+         DEBSTATUS);
 
 #define DRIVER_VERSION "0.1"
 #define DRIVER_NAME "Technisat/B2C2 FlexCop II/IIb/III Digital TV PCI Driver"
@@ -58,6 +60,8 @@ struct flexcop_pci {
         int active_dma1_addr; /* 0 = addr0 of dma1; 1 = addr1 of dma1 */
         u32 last_dma1_cur_pos; /* position of the pointer last time the timer/packet irq occured */
         int count;
+        int count_prev;
+        int stream_problem;
 
         spinlock_t irq_lock;
 
@@ -103,18 +107,32 @@ static void flexcop_pci_irq_check_work(struct work_struct *work)
                 container_of(work, struct flexcop_pci, irq_check_work.work);
         struct flexcop_device *fc = fc_pci->fc_dev;
 
-        flexcop_ibi_value v = fc->read_ibi_reg(fc,sram_dest_reg_714);
-
-        flexcop_dump_reg(fc_pci->fc_dev,dma1_000,4);
-
-        if (v.sram_dest_reg_714.net_ovflow_error)
-                deb_chk("sram net_ovflow_error\n");
-        if (v.sram_dest_reg_714.media_ovflow_error)
-                deb_chk("sram media_ovflow_error\n");
-        if (v.sram_dest_reg_714.cai_ovflow_error)
-                deb_chk("sram cai_ovflow_error\n");
-        if (v.sram_dest_reg_714.cai_ovflow_error)
-                deb_chk("sram cai_ovflow_error\n");
+        if (fc->feedcount) {
+
+                if (fc_pci->count == fc_pci->count_prev) {
+                        deb_chk("no IRQ since the last check\n");
+                        if (fc_pci->stream_problem++ == 3) {
+                                struct dvb_demux_feed *feed;
+
+                                spin_lock_irq(&fc->demux.lock);
+                                list_for_each_entry(feed, &fc->demux.feed_list,
+                                        list_head) {
+                                        flexcop_pid_feed_control(fc, feed, 0);
+                                }
+
+                                list_for_each_entry(feed, &fc->demux.feed_list,
+                                        list_head) {
+                                        flexcop_pid_feed_control(fc, feed, 1);
+                                }
+                                spin_unlock_irq(&fc->demux.lock);
+
+                                fc_pci->stream_problem = 0;
+                        }
+                } else {
+                        fc_pci->stream_problem = 0;
+                        fc_pci->count_prev = fc_pci->count;
+                }
+        }
 
         schedule_delayed_work(&fc_pci->irq_check_work,
                         msecs_to_jiffies(irq_chk_intv < 100 ? 100 : irq_chk_intv));
@@ -216,16 +234,12 @@ static int flexcop_pci_stream_control(struct flexcop_device *fc, int onoff)
                 flexcop_dma_control_timer_irq(fc,FC_DMA_1,1);
                 deb_irq("IRQ enabled\n");
 
+                fc_pci->count_prev = fc_pci->count;
+
 //              fc_pci->active_dma1_addr = 0;
 //              flexcop_dma_control_size_irq(fc,FC_DMA_1,1);
 
-                if (irq_chk_intv > 0)
-                        schedule_delayed_work(&fc_pci->irq_check_work,
-                                        msecs_to_jiffies(irq_chk_intv < 100 ? 100 : irq_chk_intv));
         } else {
-                if (irq_chk_intv > 0)
-                        cancel_delayed_work(&fc_pci->irq_check_work);
-
                 flexcop_dma_control_timer_irq(fc,FC_DMA_1,0);
                 deb_irq("IRQ disabled\n");
 
@@ -299,8 +313,6 @@ static int flexcop_pci_init(struct flexcop_pci *fc_pci)
                                         IRQF_SHARED, DRIVER_NAME, fc_pci)) != 0)
                 goto err_pci_iounmap;
 
-
-
         fc_pci->init_state |= FC_PCI_INIT;
         return ret;
 
@@ -375,6 +387,10 @@ static int flexcop_pci_probe(struct pci_dev *pdev, const struct pci_device_id *e
 
         INIT_DELAYED_WORK(&fc_pci->irq_check_work, flexcop_pci_irq_check_work);
 
+                if (irq_chk_intv > 0)
+                        schedule_delayed_work(&fc_pci->irq_check_work,
+                msecs_to_jiffies(irq_chk_intv < 100 ? 100 : irq_chk_intv));
+
         return ret;
 
 err_fc_exit:
@@ -393,6 +409,9 @@ static void flexcop_pci_remove(struct pci_dev *pdev)
 {
         struct flexcop_pci *fc_pci = pci_get_drvdata(pdev);
 
+        if (irq_chk_intv > 0)
+                cancel_delayed_work(&fc_pci->irq_check_work);
+
         flexcop_pci_dma_exit(fc_pci);
         flexcop_device_exit(fc_pci->fc_dev);
         flexcop_pci_exit(fc_pci);
diff --git a/drivers/media/dvb/b2c2/flexcop.c b/drivers/media/dvb/b2c2/flexcop.c
index 676413a915b..91068952b50 100644
--- a/drivers/media/dvb/b2c2/flexcop.c
+++ b/drivers/media/dvb/b2c2/flexcop.c
@@ -212,8 +212,7 @@ void flexcop_reset_block_300(struct flexcop_device *fc)
         v210.sw_reset_210.Block_reset_enable = 0xb2;
 
         fc->write_ibi_reg(fc,sw_reset_210,v210);
-        msleep(1);
-
+        udelay(1000);
         fc->write_ibi_reg(fc,ctrl_208,v208_save);
 }
 
diff --git a/drivers/media/video/em28xx/em28xx-audio.c b/drivers/media/video/em28xx/em28xx-audio.c
index 5d882a44e3e..2ac738fa6a0 100644
--- a/drivers/media/video/em28xx/em28xx-audio.c
+++ b/drivers/media/video/em28xx/em28xx-audio.c
@@ -463,6 +463,8 @@ static int em28xx_audio_init(struct em28xx *dev)
         pcm->info_flags = 0;
         pcm->private_data = dev;
         strcpy(pcm->name, "Empia 28xx Capture");
+
+        snd_card_set_dev(card, &dev->udev->dev);
         strcpy(card->driver, "Empia Em28xx Audio");
         strcpy(card->shortname, "Em28xx Audio");
         strcpy(card->longname, "Empia Em28xx Audio");
diff --git a/drivers/media/video/pxa_camera.c b/drivers/media/video/pxa_camera.c
index a1d6008efcb..07c334f25aa 100644
--- a/drivers/media/video/pxa_camera.c
+++ b/drivers/media/video/pxa_camera.c
@@ -1155,23 +1155,23 @@ static int pxa_camera_set_fmt(struct soc_camera_device *icd,
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct pxa_camera_dev *pcdev = ici->priv;
-        const struct soc_camera_data_format *host_fmt, *cam_fmt = NULL;
-        const struct soc_camera_format_xlate *xlate;
+        const struct soc_camera_data_format *cam_fmt = NULL;
+        const struct soc_camera_format_xlate *xlate = NULL;
         struct soc_camera_sense sense = {
                 .master_clock = pcdev->mclk,
                 .pixel_clock_max = pcdev->ciclk / 4,
         };
-        int ret, buswidth;
+        int ret;
 
-        xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
-        if (!xlate) {
-                dev_warn(&ici->dev, "Format %x not found\n", pixfmt);
-                return -EINVAL;
-        }
+        if (pixfmt) {
+                xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
+                if (!xlate) {
+                        dev_warn(&ici->dev, "Format %x not found\n", pixfmt);
+                        return -EINVAL;
+                }
 
-        buswidth = xlate->buswidth;
-        host_fmt = xlate->host_fmt;
-        cam_fmt = xlate->cam_fmt;
+                cam_fmt = xlate->cam_fmt;
+        }
 
         /* If PCLK is used to latch data from the sensor, check sense */
         if (pcdev->platform_flags & PXA_CAMERA_PCLK_EN)
@@ -1201,8 +1201,8 @@ static int pxa_camera_set_fmt(struct soc_camera_device *icd,
         }
 
         if (pixfmt && !ret) {
-                icd->buswidth = buswidth;
-                icd->current_fmt = host_fmt;
+                icd->buswidth = xlate->buswidth;
+                icd->current_fmt = xlate->host_fmt;
         }
 
         return ret;
diff --git a/drivers/media/video/sh_mobile_ceu_camera.c b/drivers/media/video/sh_mobile_ceu_camera.c
index 9a2586b07a0..ddcb81d0b81 100644
--- a/drivers/media/video/sh_mobile_ceu_camera.c
+++ b/drivers/media/video/sh_mobile_ceu_camera.c
@@ -603,21 +603,18 @@ static int sh_mobile_ceu_set_fmt(struct soc_camera_device *icd,
         const struct soc_camera_format_xlate *xlate;
         int ret;
 
+        if (!pixfmt)
+                return icd->ops->set_fmt(icd, pixfmt, rect);
+
         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
         if (!xlate) {
                 dev_warn(&ici->dev, "Format %x not found\n", pixfmt);
                 return -EINVAL;
         }
 
-        switch (pixfmt) {
-        case 0:                         /* Only geometry change */
-                ret = icd->ops->set_fmt(icd, pixfmt, rect);
-                break;
-        default:
-                ret = icd->ops->set_fmt(icd, xlate->cam_fmt->fourcc, rect);
-        }
+        ret = icd->ops->set_fmt(icd, xlate->cam_fmt->fourcc, rect);
 
-        if (pixfmt && !ret) {
+        if (!ret) {
                 icd->buswidth = xlate->buswidth;
                 icd->current_fmt = xlate->host_fmt;
                 pcdev->camera_fmt = xlate->cam_fmt;
diff --git a/drivers/misc/hpilo.c b/drivers/misc/hpilo.c
index f26667a7abf..cf991850f01 100644
--- a/drivers/misc/hpilo.c
+++ b/drivers/misc/hpilo.c
@@ -710,6 +710,7 @@ out:
 
 static struct pci_device_id ilo_devices[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_COMPAQ, 0xB204) },
+        { PCI_DEVICE(PCI_VENDOR_ID_HP, 0x3307) },
         { }
 };
 MODULE_DEVICE_TABLE(pci, ilo_devices);
@@ -758,7 +759,7 @@ static void __exit ilo_exit(void)
         class_destroy(ilo_class);
 }
 
-MODULE_VERSION("0.06");
+MODULE_VERSION("1.0");
 MODULE_ALIAS(ILO_NAME);
 MODULE_DESCRIPTION(ILO_NAME);
 MODULE_AUTHOR("David Altobelli <david.altobelli@hp.com>");
diff --git a/drivers/mtd/chips/map_rom.c b/drivers/mtd/chips/map_rom.c
index 821d0ed6bae..c76d6e5f47e 100644
--- a/drivers/mtd/chips/map_rom.c
+++ b/drivers/mtd/chips/map_rom.c
@@ -19,6 +19,7 @@ static int maprom_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
 static int maprom_write (struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
 static void maprom_nop (struct mtd_info *);
 static struct mtd_info *map_rom_probe(struct map_info *map);
+static int maprom_erase (struct mtd_info *mtd, struct erase_info *info);
 
 static struct mtd_chip_driver maprom_chipdrv = {
         .probe  = map_rom_probe,
@@ -42,6 +43,7 @@ static struct mtd_info *map_rom_probe(struct map_info *map)
         mtd->read = maprom_read;
         mtd->write = maprom_write;
         mtd->sync = maprom_nop;
+        mtd->erase = maprom_erase;
         mtd->flags = MTD_CAP_ROM;
         mtd->erasesize = map->size;
         mtd->writesize = 1;
@@ -71,6 +73,12 @@ static int maprom_write (struct mtd_info *mtd, loff_t to, size_t len, size_t *re
         return -EIO;
 }
 
+static int maprom_erase (struct mtd_info *mtd, struct erase_info *info)
+{
+        /* We do our best 8) */
+        return -EROFS;
+}
+
 static int __init map_rom_init(void)
 {
         register_mtd_chip_driver(&maprom_chipdrv);
diff --git a/drivers/mtd/devices/slram.c b/drivers/mtd/devices/slram.c
index a425d09f35a..00248e81ecd 100644
--- a/drivers/mtd/devices/slram.c
+++ b/drivers/mtd/devices/slram.c
@@ -267,22 +267,28 @@ static int parse_cmdline(char *devname, char *szstart, char *szlength)
         if (*(szlength) != '+') {
                 devlength = simple_strtoul(szlength, &buffer, 0);
                 devlength = handle_unit(devlength, buffer) - devstart;
+                if (devlength < devstart)
+                        goto err_out;
+
+                devlength -= devstart;
         } else {
                 devlength = simple_strtoul(szlength + 1, &buffer, 0);
                 devlength = handle_unit(devlength, buffer);
         }
         T("slram: devname=%s, devstart=0x%lx, devlength=0x%lx\n",
                         devname, devstart, devlength);
-        if ((devstart < 0) || (devlength < 0) || (devlength % SLRAM_BLK_SZ != 0)) {
-                E("slram: Illegal start / length parameter.\n");
-                return(-EINVAL);
-        }
+        if (devlength % SLRAM_BLK_SZ != 0)
+                goto err_out;
 
         if ((devstart = register_device(devname, devstart, devlength))){
                 unregister_devices();
                 return((int)devstart);
         }
         return(0);
+
+err_out:
+        E("slram: Illegal length parameter.\n");
+        return(-EINVAL);
 }
 
 #ifndef MODULE
diff --git a/drivers/mtd/lpddr/Kconfig b/drivers/mtd/lpddr/Kconfig
index acd4ea9b227..5a401d8047a 100644
--- a/drivers/mtd/lpddr/Kconfig
+++ b/drivers/mtd/lpddr/Kconfig
@@ -12,6 +12,7 @@ config MTD_LPDDR
           DDR memories, intended for battery-operated systems.
 
 config MTD_QINFO_PROBE
+        depends on MTD_LPDDR
         tristate "Detect flash chips by QINFO probe"
         help
             Device Information for LPDDR chips is offered through the Overlay
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index 0225cbbf22d..043d50fb6ef 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -491,7 +491,7 @@ config MTD_PCMCIA_ANONYMOUS
 
 config MTD_BFIN_ASYNC
         tristate "Blackfin BF533-STAMP Flash Chip Support"
-        depends on BFIN533_STAMP && MTD_CFI
+        depends on BFIN533_STAMP && MTD_CFI && MTD_COMPLEX_MAPPINGS
         select MTD_PARTITIONS
         default y
         help
diff --git a/drivers/mtd/maps/bfin-async-flash.c b/drivers/mtd/maps/bfin-async-flash.c
index 6fec86aaed7..576611f605d 100644
--- a/drivers/mtd/maps/bfin-async-flash.c
+++ b/drivers/mtd/maps/bfin-async-flash.c
@@ -152,14 +152,18 @@ static int __devinit bfin_flash_probe(struct platform_device *pdev)
 
         if (gpio_request(state->enet_flash_pin, DRIVER_NAME)) {
                 pr_devinit(KERN_ERR DRIVER_NAME ": Failed to request gpio %d\n", state->enet_flash_pin);
+                kfree(state);
                 return -EBUSY;
         }
         gpio_direction_output(state->enet_flash_pin, 1);
 
         pr_devinit(KERN_NOTICE DRIVER_NAME ": probing %d-bit flash bus\n", state->map.bankwidth * 8);
         state->mtd = do_map_probe(memory->name, &state->map);
-        if (!state->mtd)
+        if (!state->mtd) {
+                gpio_free(state->enet_flash_pin);
+                kfree(state);
                 return -ENXIO;
+        }
 
 #ifdef CONFIG_MTD_PARTITIONS
         ret = parse_mtd_partitions(state->mtd, part_probe_types, &pdata->parts, 0);
diff --git a/drivers/mtd/maps/ck804xrom.c b/drivers/mtd/maps/ck804xrom.c
index 5f7a245ed13..424f17d6ffd 100644
--- a/drivers/mtd/maps/ck804xrom.c
+++ b/drivers/mtd/maps/ck804xrom.c
@@ -342,9 +342,9 @@ static struct pci_device_id ck804xrom_pci_tbl[] = {
         { 0, }
 };
 
+#if 0
 MODULE_DEVICE_TABLE(pci, ck804xrom_pci_tbl);
 
-#if 0
 static struct pci_driver ck804xrom_driver = {
         .name =         MOD_NAME,
         .id_table =     ck804xrom_pci_tbl,
diff --git a/drivers/mtd/maps/physmap.c b/drivers/mtd/maps/physmap.c
index 87743661d48..4b122e7ab4b 100644
--- a/drivers/mtd/maps/physmap.c
+++ b/drivers/mtd/maps/physmap.c
@@ -29,6 +29,7 @@ struct physmap_flash_info {
         struct map_info         map[MAX_RESOURCES];
 #ifdef CONFIG_MTD_PARTITIONS
         int                     nr_parts;
+        struct mtd_partition    *parts;
 #endif
 };
 
@@ -45,25 +46,26 @@ static int physmap_flash_remove(struct platform_device *dev)
 
         physmap_data = dev->dev.platform_data;
 
-#ifdef CONFIG_MTD_CONCAT
-        if (info->cmtd != info->mtd[0]) {
+#ifdef CONFIG_MTD_PARTITIONS
+        if (info->nr_parts) {
+                del_mtd_partitions(info->cmtd);
+                kfree(info->parts);
+        } else if (physmap_data->nr_parts)
+                del_mtd_partitions(info->cmtd);
+        else
                 del_mtd_device(info->cmtd);
+#else
+        del_mtd_device(info->cmtd);
+#endif
+
+#ifdef CONFIG_MTD_CONCAT
+        if (info->cmtd != info->mtd[0])
                 mtd_concat_destroy(info->cmtd);
-        }
 #endif
 
         for (i = 0; i < MAX_RESOURCES; i++) {
-                if (info->mtd[i] != NULL) {
-#ifdef CONFIG_MTD_PARTITIONS
-                        if (info->nr_parts || physmap_data->nr_parts)
-                                del_mtd_partitions(info->mtd[i]);
-                        else
-                                del_mtd_device(info->mtd[i]);
-#else
-                        del_mtd_device(info->mtd[i]);
-#endif
+                if (info->mtd[i] != NULL)
                         map_destroy(info->mtd[i]);
-                }
         }
         return 0;
 }
@@ -86,9 +88,6 @@ static int physmap_flash_probe(struct platform_device *dev)
         int err = 0;
         int i;
         int devices_found = 0;
-#ifdef CONFIG_MTD_PARTITIONS
-        struct mtd_partition *parts;
-#endif
 
         physmap_data = dev->dev.platform_data;
         if (physmap_data == NULL)
@@ -167,10 +166,11 @@ static int physmap_flash_probe(struct platform_device *dev)
                 goto err_out;
 
 #ifdef CONFIG_MTD_PARTITIONS
-        err = parse_mtd_partitions(info->cmtd, part_probe_types, &parts, 0);
+        err = parse_mtd_partitions(info->cmtd, part_probe_types,
+                                &info->parts, 0);
         if (err > 0) {
-                add_mtd_partitions(info->cmtd, parts, err);
-                kfree(parts);
+                add_mtd_partitions(info->cmtd, info->parts, err);
+                info->nr_parts = err;
                 return 0;
         }
 
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index db85284ffb6..39ae37589fd 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -111,6 +111,7 @@ struct controller {
         int cmd_busy;
         unsigned int no_cmd_complete:1;
         unsigned int link_active_reporting:1;
+        unsigned int notification_enabled:1;
 };
 
 #define INT_BUTTON_IGNORE               0
@@ -170,6 +171,7 @@ extern int pciehp_configure_device(struct slot *p_slot);
 extern int pciehp_unconfigure_device(struct slot *p_slot);
 extern void pciehp_queue_pushbutton_work(struct work_struct *work);
 struct controller *pcie_init(struct pcie_device *dev);
+int pcie_init_notification(struct controller *ctrl);
 int pciehp_enable_slot(struct slot *p_slot);
 int pciehp_disable_slot(struct slot *p_slot);
 int pcie_enable_notification(struct controller *ctrl);
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index c2485542f54..681e3912b82 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -434,6 +434,13 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
                 goto err_out_release_ctlr;
         }
 
+        /* Enable events after we have setup the data structures */
+        rc = pcie_init_notification(ctrl);
+        if (rc) {
+                ctrl_err(ctrl, "Notification initialization failed\n");
+                goto err_out_release_ctlr;
+        }
+
         /* Check if slot is occupied */
         t_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
         t_slot->hpc_ops->get_adapter_status(t_slot, &value);
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 71a8012886b..7a16c6897bb 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -934,7 +934,7 @@ static void pcie_disable_notification(struct controller *ctrl)
                 ctrl_warn(ctrl, "Cannot disable software notification\n");
 }
 
-static int pcie_init_notification(struct controller *ctrl)
+int pcie_init_notification(struct controller *ctrl)
 {
         if (pciehp_request_irq(ctrl))
                 return -1;
@@ -942,13 +942,17 @@ static int pcie_init_notification(struct controller *ctrl)
                 pciehp_free_irq(ctrl);
                 return -1;
         }
+        ctrl->notification_enabled = 1;
         return 0;
 }
 
 static void pcie_shutdown_notification(struct controller *ctrl)
 {
-        pcie_disable_notification(ctrl);
-        pciehp_free_irq(ctrl);
+        if (ctrl->notification_enabled) {
+                pcie_disable_notification(ctrl);
+                pciehp_free_irq(ctrl);
+                ctrl->notification_enabled = 0;
+        }
 }
 
 static int pcie_init_slot(struct controller *ctrl)
@@ -1110,13 +1114,8 @@ struct controller *pcie_init(struct pcie_device *dev)
         if (pcie_init_slot(ctrl))
                 goto abort_ctrl;
 
-        if (pcie_init_notification(ctrl))
-                goto abort_slot;
-
         return ctrl;
 
-abort_slot:
-        pcie_cleanup_slot(ctrl);
 abort_ctrl:
         kfree(ctrl);
 abort:
diff --git a/drivers/pci/pcie/aer/aerdrv_core.c b/drivers/pci/pcie/aer/aerdrv_core.c
index aac7006949f..d0c97368586 100644
--- a/drivers/pci/pcie/aer/aerdrv_core.c
+++ b/drivers/pci/pcie/aer/aerdrv_core.c
@@ -108,6 +108,34 @@ int pci_cleanup_aer_correct_error_status(struct pci_dev *dev)
 }
 #endif  /*  0  */
 
+
+static void set_device_error_reporting(struct pci_dev *dev, void *data)
+{
+        bool enable = *((bool *)data);
+
+        if (dev->pcie_type != PCIE_RC_PORT &&
+            dev->pcie_type != PCIE_SW_UPSTREAM_PORT &&
+            dev->pcie_type != PCIE_SW_DOWNSTREAM_PORT)
+                return;
+
+        if (enable)
+                pci_enable_pcie_error_reporting(dev);
+        else
+                pci_disable_pcie_error_reporting(dev);
+}
+
+/**
+ * set_downstream_devices_error_reporting - enable/disable the error reporting  bits on the root port and its downstream ports.
+ * @dev: pointer to root port's pci_dev data structure
+ * @enable: true = enable error reporting, false = disable error reporting.
+ */
+static void set_downstream_devices_error_reporting(struct pci_dev *dev,
+                                                   bool enable)
+{
+        set_device_error_reporting(dev, &enable);
+        pci_walk_bus(dev->subordinate, set_device_error_reporting, &enable);
+}
+
 static int find_device_iter(struct device *device, void *data)
 {
         struct pci_dev *dev;
@@ -525,15 +553,11 @@ void aer_enable_rootport(struct aer_rpc *rpc)
         pci_read_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, &reg32);
         pci_write_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, reg32);
 
-        /* Enable Root Port device reporting error itself */
-        pci_read_config_word(pdev, pos+PCI_EXP_DEVCTL, &reg16);
-        reg16 = reg16 |
-                PCI_EXP_DEVCTL_CERE |
-                PCI_EXP_DEVCTL_NFERE |
-                PCI_EXP_DEVCTL_FERE |
-                PCI_EXP_DEVCTL_URRE;
-        pci_write_config_word(pdev, pos+PCI_EXP_DEVCTL,
-                reg16);
+        /*
+         * Enable error reporting for the root port device and downstream port
+         * devices.
+         */
+        set_downstream_devices_error_reporting(pdev, true);
 
         /* Enable Root Port's interrupt in response to error messages */
         pci_write_config_dword(pdev,
@@ -553,6 +577,12 @@ static void disable_root_aer(struct aer_rpc *rpc)
         u32 reg32;
         int pos;
 
+        /*
+         * Disable error reporting for the root port device and downstream port
+         * devices.
+         */
+        set_downstream_devices_error_reporting(pdev, false);
+
         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
         /* Disable Root's interrupt in response to error messages */
         pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, 0);
diff --git a/drivers/pci/pcie/portdrv_pci.c b/drivers/pci/pcie/portdrv_pci.c
index f9b874eaeb9..248b4db9155 100644
--- a/drivers/pci/pcie/portdrv_pci.c
+++ b/drivers/pci/pcie/portdrv_pci.c
@@ -97,8 +97,6 @@ static int __devinit pcie_portdrv_probe (struct pci_dev *dev,
 
         pcie_portdrv_save_config(dev);
 
-        pci_enable_pcie_error_reporting(dev);
-
         return 0;
 }
 
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index baad093aafe..f20d55368ed 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -1584,6 +1584,7 @@ DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_SERVERWORKS,   PCI_DEVICE_ID_SERVERWORKS_
  */
 #define AMD_813X_MISC                   0x40
 #define AMD_813X_NOIOAMODE              (1<<0)
+#define AMD_813X_REV_B2                 0x13
 
 static void quirk_disable_amd_813x_boot_interrupt(struct pci_dev *dev)
 {
@@ -1591,6 +1592,8 @@ static void quirk_disable_amd_813x_boot_interrupt(struct pci_dev *dev)
 
         if (noioapicquirk)
                 return;
+        if (dev->revision == AMD_813X_REV_B2)
+                return;
 
         pci_read_config_dword(dev, AMD_813X_MISC, &pci_config_dword);
         pci_config_dword &= ~AMD_813X_NOIOAMODE;
@@ -1981,7 +1984,6 @@ static void __devinit quirk_msi_ht_cap(struct pci_dev *dev)
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT2000_PCIE,
                         quirk_msi_ht_cap);
 
-
 /* The nVidia CK804 chipset may have 2 HT MSI mappings.
  * MSI are supported if the MSI capability set in any of these mappings.
  */
@@ -2032,6 +2034,9 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SERVERWORKS,
                          PCI_DEVICE_ID_SERVERWORKS_HT1000_PXB,
                          ht_enable_msi_mapping);
 
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8132_BRIDGE,
+                         ht_enable_msi_mapping);
+
 /* The P5N32-SLI Premium motherboard from Asus has a problem with msi
  * for the MCP55 NIC. It is not yet determined whether the msi problem
  * also affects other devices. As for now, turn off msi for this device.
@@ -2048,10 +2053,100 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA,
                         PCI_DEVICE_ID_NVIDIA_NVENET_15,
                         nvenet_msi_disable);
 
-static void __devinit nv_msi_ht_cap_quirk(struct pci_dev *dev)
+static void __devinit nv_ht_enable_msi_mapping(struct pci_dev *dev)
 {
         struct pci_dev *host_bridge;
+        int pos;
+        int i, dev_no;
+        int found = 0;
+
+        dev_no = dev->devfn >> 3;
+        for (i = dev_no; i >= 0; i--) {
+                host_bridge = pci_get_slot(dev->bus, PCI_DEVFN(i, 0));
+                if (!host_bridge)
+                        continue;
+
+                pos = pci_find_ht_capability(host_bridge, HT_CAPTYPE_SLAVE);
+                if (pos != 0) {
+                        found = 1;
+                        break;
+                }
+                pci_dev_put(host_bridge);
+        }
+
+        if (!found)
+                return;
+
+        /* root did that ! */
+        if (msi_ht_cap_enabled(host_bridge))
+                goto out;
+
+        ht_enable_msi_mapping(dev);
+
+out:
+        pci_dev_put(host_bridge);
+}
+
+static void __devinit ht_disable_msi_mapping(struct pci_dev *dev)
+{
+        int pos, ttl = 48;
+
+        pos = pci_find_ht_capability(dev, HT_CAPTYPE_MSI_MAPPING);
+        while (pos && ttl--) {
+                u8 flags;
+
+                if (pci_read_config_byte(dev, pos + HT_MSI_FLAGS,
+                                         &flags) == 0) {
+                        dev_info(&dev->dev, "Enabling HT MSI Mapping\n");
+
+                        pci_write_config_byte(dev, pos + HT_MSI_FLAGS,
+                                              flags & ~HT_MSI_FLAGS_ENABLE);
+                }
+                pos = pci_find_next_ht_capability(dev, pos,
+                                                  HT_CAPTYPE_MSI_MAPPING);
+        }
+}
+
+static int __devinit ht_check_msi_mapping(struct pci_dev *dev)
+{
         int pos, ttl = 48;
+        int found = 0;
+
+        /* check if there is HT MSI cap or enabled on this device */
+        pos = pci_find_ht_capability(dev, HT_CAPTYPE_MSI_MAPPING);
+        while (pos && ttl--) {
+                u8 flags;
+
+                if (found < 1)
+                        found = 1;
+                if (pci_read_config_byte(dev, pos + HT_MSI_FLAGS,
+                                         &flags) == 0) {
+                        if (flags & HT_MSI_FLAGS_ENABLE) {
+                                if (found < 2) {
+                                        found = 2;
+                                        break;
+                                }
+                        }
+                }
+                pos = pci_find_next_ht_capability(dev, pos,
+                                                  HT_CAPTYPE_MSI_MAPPING);
+        }
+
+        return found;
+}
+
+static void __devinit nv_msi_ht_cap_quirk(struct pci_dev *dev)
+{
+        struct pci_dev *host_bridge;
+        int pos;
+        int found;
+
+        /* check if there is HT MSI cap or enabled on this device */
+        found = ht_check_msi_mapping(dev);
+
+        /* no HT MSI CAP */
+        if (found == 0)
+                return;
 
         /*
          * HT MSI mapping should be disabled on devices that are below
@@ -2067,24 +2162,19 @@ static void __devinit nv_msi_ht_cap_quirk(struct pci_dev *dev)
         pos = pci_find_ht_capability(host_bridge, HT_CAPTYPE_SLAVE);
         if (pos != 0) {
                 /* Host bridge is to HT */
-                ht_enable_msi_mapping(dev);
+                if (found == 1) {
+                        /* it is not enabled, try to enable it */
+                        nv_ht_enable_msi_mapping(dev);
+                }
                 return;
         }
 
-        /* Host bridge is not to HT, disable HT MSI mapping on this device */
-        pos = pci_find_ht_capability(dev, HT_CAPTYPE_MSI_MAPPING);
-        while (pos && ttl--) {
-                u8 flags;
+        /* HT MSI is not enabled */
+        if (found == 1)
+                return;
 
-                if (pci_read_config_byte(dev, pos + HT_MSI_FLAGS,
-                                         &flags) == 0) {
-                        dev_info(&dev->dev, "Disabling HT MSI mapping");
-                        pci_write_config_byte(dev, pos + HT_MSI_FLAGS,
-                                              flags & ~HT_MSI_FLAGS_ENABLE);
-                }
-                pos = pci_find_next_ht_capability(dev, pos,
-                                                  HT_CAPTYPE_MSI_MAPPING);
-        }
+        /* Host bridge is not to HT, disable HT MSI mapping on this device */
+        ht_disable_msi_mapping(dev);
 }
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID, nv_msi_ht_cap_quirk);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AL, PCI_ANY_ID, nv_msi_ht_cap_quirk);
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index 3599828b976..022e89ffec1 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -133,7 +133,7 @@
 # define SCSPTR3        0xffed0024      /* 16 bit SCIF */
 # define SCSPTR4        0xffee0024      /* 16 bit SCIF */
 # define SCSPTR5        0xffef0024      /* 16 bit SCIF */
-# define SCIF_OPER      0x0001          /* Overrun error bit */
+# define SCIF_ORER      0x0001          /* Overrun error bit */
 # define SCSCR_INIT(port)       0x3a    /* TIE=0,RIE=0,TE=1,RE=1,REIE=1 */
 #elif defined(CONFIG_CPU_SUBTYPE_SH7201) || \
       defined(CONFIG_CPU_SUBTYPE_SH7203) || \
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 326dd7f65ee..b3d5a23ab56 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -1376,6 +1376,15 @@ static struct usb_device_id acm_ids[] = {
         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
         },
+        { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
+        },
+        { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
+        .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
+                                           data interface instead of
+                                           communications interface.
+                                           Maybe we should define a new
+                                           quirk for this. */
+        },
 
         /* control interfaces with various AT-command sets */
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 31fb204f44c..49e7f56e0d7 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -653,7 +653,7 @@ int usb_get_descriptor(struct usb_device *dev, unsigned char type,
                 if (result <= 0 && result != -ETIMEDOUT)
                         continue;
                 if (result > 1 && ((u8 *)buf)[1] != type) {
-                        result = -EPROTO;
+                        result = -ENODATA;
                         continue;
                 }
                 break;
@@ -696,8 +696,13 @@ static int usb_get_string(struct usb_device *dev, unsigned short langid,
                         USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
                         (USB_DT_STRING << 8) + index, langid, buf, size,
                         USB_CTRL_GET_TIMEOUT);
-                if (!(result == 0 || result == -EPIPE))
-                        break;
+                if (result == 0 || result == -EPIPE)
+                        continue;
+                if (result > 1 && ((u8 *) buf)[1] != USB_DT_STRING) {
+                        result = -ENODATA;
+                        continue;
+                }
+                break;
         }
         return result;
 }
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 3219d137340..e55fef52a5d 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -191,6 +191,7 @@ config USB_GADGET_OMAP
         boolean "OMAP USB Device Controller"
         depends on ARCH_OMAP
         select ISP1301_OMAP if MACH_OMAP_H2 || MACH_OMAP_H3 || MACH_OMAP_H4_OTG
+        select USB_OTG_UTILS if ARCH_OMAP
         help
            Many Texas Instruments OMAP processors have flexible full
            speed USB device controllers, with support for up to 30
diff --git a/drivers/usb/gadget/f_obex.c b/drivers/usb/gadget/f_obex.c
index 80c2e7e9622..38aa896cc5d 100644
--- a/drivers/usb/gadget/f_obex.c
+++ b/drivers/usb/gadget/f_obex.c
@@ -366,9 +366,9 @@ obex_bind(struct usb_configuration *c, struct usb_function *f)
                 f->hs_descriptors = usb_copy_descriptors(hs_function);
 
                 obex->hs.obex_in = usb_find_endpoint(hs_function,
-                                f->descriptors, &obex_hs_ep_in_desc);
+                                f->hs_descriptors, &obex_hs_ep_in_desc);
                 obex->hs.obex_out = usb_find_endpoint(hs_function,
-                                f->descriptors, &obex_hs_ep_out_desc);
+                                f->hs_descriptors, &obex_hs_ep_out_desc);
         }
 
         /* Avoid letting this gadget enumerate until the userspace
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index b10fa31cc91..1ab9dac7e12 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -3879,7 +3879,11 @@ static int __init check_parameters(struct fsg_dev *fsg)
         mod_data.protocol_type = USB_SC_SCSI;
         mod_data.protocol_name = "Transparent SCSI";
 
-        if (gadget_is_sh(fsg->gadget))
+        /* Some peripheral controllers are known not to be able to
+         * halt bulk endpoints correctly.  If one of them is present,
+         * disable stalls.
+         */
+        if (gadget_is_sh(fsg->gadget) || gadget_is_at91(fsg->gadget))
                 mod_data.can_stall = 0;
 
         if (mod_data.release == 0xffff) {       // Parameter wasn't set
diff --git a/drivers/usb/gadget/fsl_usb2_udc.c b/drivers/usb/gadget/fsl_usb2_udc.c
index f3c6703cffd..d8d9a52a44b 100644
--- a/drivers/usb/gadget/fsl_usb2_udc.c
+++ b/drivers/usb/gadget/fsl_usb2_udc.c
@@ -404,7 +404,10 @@ static void struct_ep_qh_setup(struct fsl_udc *udc, unsigned char ep_num,
         }
         if (zlt)
                 tmp |= EP_QUEUE_HEAD_ZLT_SEL;
+
         p_QH->max_pkt_length = cpu_to_le32(tmp);
+        p_QH->next_dtd_ptr = 1;
+        p_QH->size_ioc_int_sts = 0;
 
         return;
 }
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 4725d15d096..e551bb38852 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -485,6 +485,7 @@ static int ehci_init(struct usb_hcd *hcd)
          * periodic_size can shrink by USBCMD update if hcc_params allows.
          */
         ehci->periodic_size = DEFAULT_I_TDPS;
+        INIT_LIST_HEAD(&ehci->cached_itd_list);
         if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
                 return retval;
 
@@ -497,6 +498,7 @@ static int ehci_init(struct usb_hcd *hcd)
 
         ehci->reclaim = NULL;
         ehci->next_uframe = -1;
+        ehci->clock_frame = -1;
 
         /*
          * dedicate a qh for the async ring head, since we couldn't unlink
diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
index 0431397836f..10d52919abb 100644
--- a/drivers/usb/host/ehci-mem.c
+++ b/drivers/usb/host/ehci-mem.c
@@ -128,6 +128,7 @@ static inline void qh_put (struct ehci_qh *qh)
 
 static void ehci_mem_cleanup (struct ehci_hcd *ehci)
 {
+        free_cached_itd_list(ehci);
         if (ehci->async)
                 qh_put (ehci->async);
         ehci->async = NULL;
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index a081ee65bde..07bcb931021 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -1004,7 +1004,8 @@ iso_stream_put(struct ehci_hcd *ehci, struct ehci_iso_stream *stream)
 
                 is_in = (stream->bEndpointAddress & USB_DIR_IN) ? 0x10 : 0;
                 stream->bEndpointAddress &= 0x0f;
-                stream->ep->hcpriv = NULL;
+                if (stream->ep)
+                        stream->ep->hcpriv = NULL;
 
                 if (stream->rescheduled) {
                         ehci_info (ehci, "ep%d%s-iso rescheduled "
@@ -1653,14 +1654,28 @@ itd_complete (
                         (stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out");
         }
         iso_stream_put (ehci, stream);
-        /* OK to recycle this ITD now that its completion callback ran. */
+
 done:
         usb_put_urb(urb);
         itd->urb = NULL;
-        itd->stream = NULL;
-        list_move(&itd->itd_list, &stream->free_list);
-        iso_stream_put(ehci, stream);
-
+        if (ehci->clock_frame != itd->frame || itd->index[7] != -1) {
+                /* OK to recycle this ITD now. */
+                itd->stream = NULL;
+                list_move(&itd->itd_list, &stream->free_list);
+                iso_stream_put(ehci, stream);
+        } else {
+                /* HW might remember this ITD, so we can't recycle it yet.
+                 * Move it to a safe place until a new frame starts.
+                 */
+                list_move(&itd->itd_list, &ehci->cached_itd_list);
+                if (stream->refcount == 2) {
+                        /* If iso_stream_put() were called here, stream
+                         * would be freed.  Instead, just prevent reuse.
+                         */
+                        stream->ep->hcpriv = NULL;
+                        stream->ep = NULL;
+                }
+        }
         return retval;
 }
 
@@ -2101,6 +2116,20 @@ done:
 
 /*-------------------------------------------------------------------------*/
 
+static void free_cached_itd_list(struct ehci_hcd *ehci)
+{
+        struct ehci_itd *itd, *n;
+
+        list_for_each_entry_safe(itd, n, &ehci->cached_itd_list, itd_list) {
+                struct ehci_iso_stream  *stream = itd->stream;
+                itd->stream = NULL;
+                list_move(&itd->itd_list, &stream->free_list);
+                iso_stream_put(ehci, stream);
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
 static void
 scan_periodic (struct ehci_hcd *ehci)
 {
@@ -2115,10 +2144,17 @@ scan_periodic (struct ehci_hcd *ehci)
          * Touches as few pages as possible:  cache-friendly.
          */
         now_uframe = ehci->next_uframe;
-        if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state))
+        if (HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
                 clock = ehci_readl(ehci, &ehci->regs->frame_index);
-        else
+                clock_frame = (clock >> 3) % ehci->periodic_size;
+        } else  {
                 clock = now_uframe + mod - 1;
+                clock_frame = -1;
+        }
+        if (ehci->clock_frame != clock_frame) {
+                free_cached_itd_list(ehci);
+                ehci->clock_frame = clock_frame;
+        }
         clock %= mod;
         clock_frame = clock >> 3;
 
@@ -2277,6 +2313,10 @@ restart:
                         /* rescan the rest of this frame, then ... */
                         clock = now;
                         clock_frame = clock >> 3;
+                        if (ehci->clock_frame != clock_frame) {
+                                free_cached_itd_list(ehci);
+                                ehci->clock_frame = clock_frame;
+                        }
                 } else {
                         now_uframe++;
                         now_uframe %= mod;
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index fb7054ccf4f..262b00c9b33 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -87,6 +87,10 @@ struct ehci_hcd {			/* one per controller */
         int                     next_uframe;    /* scan periodic, start here */
         unsigned                periodic_sched; /* periodic activity count */
 
+        /* list of itds completed while clock_frame was still active */
+        struct list_head        cached_itd_list;
+        unsigned                clock_frame;
+
         /* per root hub port */
         unsigned long           reset_done [EHCI_MAX_ROOT_PORTS];
 
@@ -220,6 +224,8 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
         }
 }
 
+static void free_cached_itd_list(struct ehci_hcd *ehci);
+
 /*-------------------------------------------------------------------------*/
 
 #include <linux/usb/ehci_def.h>
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 5a8fd5d57a1..2dc7606f319 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -377,18 +377,8 @@ int __init musb_platform_init(struct musb *musb)
         u32             revision;
 
         musb->mregs += DAVINCI_BASE_OFFSET;
-#if 0
-        /* REVISIT there's something odd about clocking, this
-         * didn't appear do the job ...
-         */
-        musb->clock = clk_get(pDevice, "usb");
-        if (IS_ERR(musb->clock))
-                return PTR_ERR(musb->clock);
 
-        status = clk_enable(musb->clock);
-        if (status < 0)
-                return -ENODEV;
-#endif
+        clk_enable(musb->clock);
 
         /* returns zero if e.g. not clocked */
         revision = musb_readl(tibase, DAVINCI_USB_VERSION_REG);
@@ -453,5 +443,8 @@ int musb_platform_exit(struct musb *musb)
         }
 
         phy_off();
+
+        clk_disable(musb->clock);
+
         return 0;
 }
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 2cc34fa05b7..af77e465900 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -115,7 +115,7 @@
 
 
 unsigned musb_debug;
-module_param(musb_debug, uint, S_IRUGO | S_IWUSR);
+module_param_named(debug, musb_debug, uint, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug message level. Default = 0");
 
 #define DRIVER_AUTHOR "Mentor Graphics, Texas Instruments, Nokia"
@@ -767,6 +767,7 @@ static irqreturn_t musb_stage2_irq(struct musb *musb, u8 int_usb,
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
                 case OTG_STATE_A_HOST:
                 case OTG_STATE_A_SUSPEND:
+                        usb_hcd_resume_root_hub(musb_to_hcd(musb));
                         musb_root_disconnect(musb);
                         if (musb->a_wait_bcon != 0)
                                 musb_platform_try_idle(musb, jiffies
@@ -1815,7 +1816,7 @@ static void musb_free(struct musb *musb)
 #ifdef CONFIG_SYSFS
         device_remove_file(musb->controller, &dev_attr_mode);
         device_remove_file(musb->controller, &dev_attr_vbus);
-#ifdef CONFIG_USB_MUSB_OTG
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
         device_remove_file(musb->controller, &dev_attr_srp);
 #endif
 #endif
@@ -2063,7 +2064,7 @@ fail2:
 #ifdef CONFIG_SYSFS
         device_remove_file(musb->controller, &dev_attr_mode);
         device_remove_file(musb->controller, &dev_attr_vbus);
-#ifdef CONFIG_USB_MUSB_OTG
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
         device_remove_file(musb->controller, &dev_attr_srp);
 #endif
 #endif
@@ -2243,10 +2244,10 @@ static int __init musb_init(void)
         return platform_driver_probe(&musb_driver, musb_probe);
 }
 
-/* make us init after usbcore and before usb
- * gadget and host-side drivers start to register
+/* make us init after usbcore and i2c (transceivers, regulators, etc)
+ * and before usb gadget and host-side drivers start to register
  */
-subsys_initcall(musb_init);
+fs_initcall(musb_init);
 
 static void __exit musb_cleanup(void)
 {
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 4ea30538798..c7ebd0867fc 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -575,7 +575,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
         struct usb_request      *request = &req->request;
         struct musb_ep          *musb_ep = &musb->endpoints[epnum].ep_out;
         void __iomem            *epio = musb->endpoints[epnum].regs;
-        u16                     fifo_count = 0;
+        unsigned                fifo_count = 0;
         u16                     len = musb_ep->packet_sz;
 
         csr = musb_readw(epio, MUSB_RXCSR);
@@ -687,7 +687,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                         len, fifo_count,
                                         musb_ep->packet_sz);
 
-                        fifo_count = min(len, fifo_count);
+                        fifo_count = min_t(unsigned, len, fifo_count);
 
 #ifdef  CONFIG_USB_TUSB_OMAP_DMA
                         if (tusb_dma_omap() && musb_ep->dma) {
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index a035ceccf95..6dbbd0786a6 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -335,16 +335,11 @@ musb_save_toggle(struct musb_hw_ep *ep, int is_in, struct urb *urb)
 static struct musb_qh *
 musb_giveback(struct musb_qh *qh, struct urb *urb, int status)
 {
-        int                     is_in;
         struct musb_hw_ep       *ep = qh->hw_ep;
         struct musb             *musb = ep->musb;
+        int                     is_in = usb_pipein(urb->pipe);
         int                     ready = qh->is_ready;
 
-        if (ep->is_shared_fifo)
-                is_in = 1;
-        else
-                is_in = usb_pipein(urb->pipe);
-
         /* save toggle eagerly, for paranoia */
         switch (qh->type) {
         case USB_ENDPOINT_XFER_BULK:
@@ -432,7 +427,7 @@ musb_advance_schedule(struct musb *musb, struct urb *urb,
         else
                 qh = musb_giveback(qh, urb, urb->status);
 
-        if (qh && qh->is_ready && !list_empty(&qh->hep->urb_list)) {
+        if (qh != NULL && qh->is_ready) {
                 DBG(4, "... next ep%d %cX urb %p\n",
                                 hw_ep->epnum, is_in ? 'R' : 'T',
                                 next_urb(qh));
@@ -942,8 +937,8 @@ static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)
         switch (musb->ep0_stage) {
         case MUSB_EP0_IN:
                 fifo_dest = urb->transfer_buffer + urb->actual_length;
-                fifo_count = min(len, ((u16) (urb->transfer_buffer_length
-                                        - urb->actual_length)));
+                fifo_count = min_t(size_t, len, urb->transfer_buffer_length -
+                                   urb->actual_length);
                 if (fifo_count < len)
                         urb->status = -EOVERFLOW;
 
@@ -976,10 +971,9 @@ static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)
                 }
                 /* FALLTHROUGH */
         case MUSB_EP0_OUT:
-                fifo_count = min(qh->maxpacket, ((u16)
-                                (urb->transfer_buffer_length
-                                - urb->actual_length)));
-
+                fifo_count = min_t(size_t, qh->maxpacket,
+                                   urb->transfer_buffer_length -
+                                   urb->actual_length);
                 if (fifo_count) {
                         fifo_dest = (u8 *) (urb->transfer_buffer
                                         + urb->actual_length);
@@ -1161,7 +1155,8 @@ void musb_host_tx(struct musb *musb, u8 epnum)
         struct urb              *urb;
         struct musb_hw_ep       *hw_ep = musb->endpoints + epnum;
         void __iomem            *epio = hw_ep->regs;
-        struct musb_qh          *qh = hw_ep->out_qh;
+        struct musb_qh          *qh = hw_ep->is_shared_fifo ? hw_ep->in_qh
+                                                            : hw_ep->out_qh;
         u32                     status = 0;
         void __iomem            *mbase = musb->mregs;
         struct dma_channel      *dma;
@@ -1308,7 +1303,8 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                  * packets before updating TXCSR ... other docs disagree ...
                  */
                 /* PIO:  start next packet in this URB */
-                wLength = min(qh->maxpacket, (u16) wLength);
+                if (wLength > qh->maxpacket)
+                        wLength = qh->maxpacket;
                 musb_write_fifo(hw_ep, wLength, buf);
                 qh->segsize = wLength;
 
@@ -1867,19 +1863,21 @@ static int musb_urb_enqueue(
         }
         qh->type_reg = type_reg;
 
-        /* precompute rxinterval/txinterval register */
-        interval = min((u8)16, epd->bInterval); /* log encoding */
+        /* Precompute RXINTERVAL/TXINTERVAL register */
         switch (qh->type) {
         case USB_ENDPOINT_XFER_INT:
-                /* fullspeed uses linear encoding */
-                if (USB_SPEED_FULL == urb->dev->speed) {
-                        interval = epd->bInterval;
-                        if (!interval)
-                                interval = 1;
+                /*
+                 * Full/low speeds use the  linear encoding,
+                 * high speed uses the logarithmic encoding.
+                 */
+                if (urb->dev->speed <= USB_SPEED_FULL) {
+                        interval = max_t(u8, epd->bInterval, 1);
+                        break;
                 }
                 /* FALLTHROUGH */
         case USB_ENDPOINT_XFER_ISOC:
-                /* iso always uses log encoding */
+                /* ISO always uses logarithmic encoding */
+                interval = min_t(u8, epd->bInterval, 16);
                 break;
         default:
                 /* REVISIT we actually want to use NAK limits, hinting to the
@@ -2037,9 +2035,9 @@ static int musb_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 goto done;
 
         /* Any URB not actively programmed into endpoint hardware can be
-         * immediately given back.  Such an URB must be at the head of its
+         * immediately given back; that's any URB not at the head of an
          * endpoint queue, unless someday we get real DMA queues.  And even
-         * then, it might not be known to the hardware...
+         * if it's at the head, it might not be known to the hardware...
          *
          * Otherwise abort current transfer, pending dma, etc.; urb->status
          * has already been updated.  This is a synchronous abort; it'd be
@@ -2078,6 +2076,15 @@ static int musb_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 qh->is_ready = 0;
                 __musb_giveback(musb, urb, 0);
                 qh->is_ready = ready;
+
+                /* If nothing else (usually musb_giveback) is using it
+                 * and its URB list has emptied, recycle this qh.
+                 */
+                if (ready && list_empty(&qh->hep->urb_list)) {
+                        qh->hep->hcpriv = NULL;
+                        list_del(&qh->ring);
+                        kfree(qh);
+                }
         } else
                 ret = musb_cleanup_urb(urb, qh, urb->pipe & USB_DIR_IN);
 done:
@@ -2093,15 +2100,16 @@ musb_h_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep)
         unsigned long           flags;
         struct musb             *musb = hcd_to_musb(hcd);
         u8                      is_in = epnum & USB_DIR_IN;
-        struct musb_qh          *qh = hep->hcpriv;
-        struct urb              *urb, *tmp;
+        struct musb_qh          *qh;
+        struct urb              *urb;
         struct list_head        *sched;
 
-        if (!qh)
-                return;
-
         spin_lock_irqsave(&musb->lock, flags);
 
+        qh = hep->hcpriv;
+        if (qh == NULL)
+                goto exit;
+
         switch (qh->type) {
         case USB_ENDPOINT_XFER_CONTROL:
                 sched = &musb->control;
@@ -2135,13 +2143,28 @@ musb_h_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep)
 
                 /* cleanup */
                 musb_cleanup_urb(urb, qh, urb->pipe & USB_DIR_IN);
-        } else
-                urb = NULL;
 
-        /* then just nuke all the others */
-        list_for_each_entry_safe_from(urb, tmp, &hep->urb_list, urb_list)
-                musb_giveback(qh, urb, -ESHUTDOWN);
+                /* Then nuke all the others ... and advance the
+                 * queue on hw_ep (e.g. bulk ring) when we're done.
+                 */
+                while (!list_empty(&hep->urb_list)) {
+                        urb = next_urb(qh);
+                        urb->status = -ESHUTDOWN;
+                        musb_advance_schedule(musb, urb, qh->hw_ep, is_in);
+                }
+        } else {
+                /* Just empty the queue; the hardware is busy with
+                 * other transfers, and since !qh->is_ready nothing
+                 * will activate any of these as it advances.
+                 */
+                while (!list_empty(&hep->urb_list))
+                        __musb_giveback(musb, next_urb(qh), -ESHUTDOWN);
 
+                hep->hcpriv = NULL;
+                list_del(&qh->ring);
+                kfree(qh);
+        }
+exit:
         spin_unlock_irqrestore(&musb->lock, flags);
 }
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index bfd0b68cecc..b7c132bded7 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -294,7 +294,11 @@ static int  option_send_setup(struct tty_struct *tty, struct usb_serial_port *po
 
 /* Ericsson products */
 #define ERICSSON_VENDOR_ID                      0x0bdb
-#define ERICSSON_PRODUCT_F3507G                 0x1900
+#define ERICSSON_PRODUCT_F3507G_1               0x1900
+#define ERICSSON_PRODUCT_F3507G_2               0x1902
+
+#define BENQ_VENDOR_ID                          0x04a5
+#define BENQ_PRODUCT_H10                        0x4068
 
 static struct usb_device_id option_ids[] = {
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
@@ -509,7 +513,10 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(ZTE_VENDOR_ID, ZTE_PRODUCT_MF626) },
         { USB_DEVICE(ZTE_VENDOR_ID, ZTE_PRODUCT_MF628) },
         { USB_DEVICE(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH) },
-        { USB_DEVICE(ERICSSON_VENDOR_ID, ERICSSON_PRODUCT_F3507G) },
+        { USB_DEVICE(ERICSSON_VENDOR_ID, ERICSSON_PRODUCT_F3507G_1) },
+        { USB_DEVICE(ERICSSON_VENDOR_ID, ERICSSON_PRODUCT_F3507G_2) },
+        { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) },
+        { USB_DEVICE(0x1da5, 0x4515) }, /* BenQ H20 */
         { } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 50dc33a6065..6f59c8e510e 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -907,13 +907,13 @@ UNUSUAL_DEV(  0x05e3, 0x0701, 0x0000, 0xffff,
                 "Genesys Logic",
                 "USB to IDE Optical",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 ),
+                US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ),
 
 UNUSUAL_DEV(  0x05e3, 0x0702, 0x0000, 0xffff,
                 "Genesys Logic",
                 "USB to IDE Disk",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 ),
+                US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ),
 
 /* Reported by Ben Efros <ben@pc-doctor.com> */
 UNUSUAL_DEV(  0x05e3, 0x0723, 0x9451, 0x9451,
diff --git a/drivers/w1/slaves/Kconfig b/drivers/w1/slaves/Kconfig
index 8d0b1fb1e52..1f51366417b 100644
--- a/drivers/w1/slaves/Kconfig
+++ b/drivers/w1/slaves/Kconfig
@@ -16,6 +16,12 @@ config W1_SLAVE_SMEM
           Say Y here if you want to connect 1-wire
           simple 64bit memory rom(ds2401/ds2411/ds1990*) to your wire.
 
+config W1_SLAVE_DS2431
+        tristate "1kb EEPROM family support (DS2431)"
+        help
+          Say Y here if you want to use a 1-wire
+          1kb EEPROM family device (DS2431)
+
 config W1_SLAVE_DS2433
         tristate "4kb EEPROM family support (DS2433)"
         help
diff --git a/drivers/w1/slaves/Makefile b/drivers/w1/slaves/Makefile
index 990f400b6d2..f1f51f19b12 100644
--- a/drivers/w1/slaves/Makefile
+++ b/drivers/w1/slaves/Makefile
@@ -4,6 +4,7 @@
 
 obj-$(CONFIG_W1_SLAVE_THERM)    += w1_therm.o
 obj-$(CONFIG_W1_SLAVE_SMEM)     += w1_smem.o
+obj-$(CONFIG_W1_SLAVE_DS2431)   += w1_ds2431.o
 obj-$(CONFIG_W1_SLAVE_DS2433)   += w1_ds2433.o
 obj-$(CONFIG_W1_SLAVE_DS2760)   += w1_ds2760.o
 obj-$(CONFIG_W1_SLAVE_BQ27000)  += w1_bq27000.o
diff --git a/drivers/w1/slaves/w1_ds2433.c b/drivers/w1/slaves/w1_ds2433.c
index 858c16a544c..13944714882 100644
--- a/drivers/w1/slaves/w1_ds2433.c
+++ b/drivers/w1/slaves/w1_ds2433.c
@@ -156,6 +156,9 @@ out_up:
  */
 static int w1_f23_write(struct w1_slave *sl, int addr, int len, const u8 *data)
 {
+#ifdef CONFIG_W1_SLAVE_DS2433_CRC
+        struct w1_f23_data *f23 = sl->family_data;
+#endif
         u8 wrbuf[4];
         u8 rdbuf[W1_PAGE_SIZE + 3];
         u8 es = (addr + len - 1) & 0x1f;
@@ -196,7 +199,9 @@ static int w1_f23_write(struct w1_slave *sl, int addr, int len, const u8 *data)
 
         /* Reset the bus to wake up the EEPROM (this may not be needed) */
         w1_reset_bus(sl->master);
-
+#ifdef CONFIG_W1_SLAVE_DS2433_CRC
+        f23->validcrc &= ~(1 << (addr >> W1_PAGE_BITS));
+#endif
         return 0;
 }