35 files changed, 579 insertions, 361 deletions

diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 5109fa37c662..ad1d7065a1b2 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4177,6 +4177,11 @@ static int __init floppy_init(void)
         int i, unit, drive;
         int err, dr;
 
+#if defined(CONFIG_PPC_MERGE)
+        if (check_legacy_ioport(FDC1))
+                return -ENODEV;
+#endif
+
         raw_cmd = NULL;
 
         for (dr = 0; dr < N_DRIVE; dr++) {
@@ -4234,13 +4239,6 @@ static int __init floppy_init(void)
         }
 
         use_virtual_dma = can_use_virtual_dma & 1;
-#if defined(CONFIG_PPC_MERGE)
-        if (check_legacy_ioport(FDC1)) {
-                del_timer(&fd_timeout);
-                err = -ENODEV;
-                goto out_unreg_region;
-        }
-#endif
         fdc_state[0].address = FDC1;
         if (fdc_state[0].address == -1) {
                 del_timer(&fd_timeout);
diff --git a/drivers/char/drm/radeon_state.c b/drivers/char/drm/radeon_state.c
index 5bb2234a9094..39a7f685e3fd 100644
--- a/drivers/char/drm/radeon_state.c
+++ b/drivers/char/drm/radeon_state.c
@@ -175,6 +175,14 @@ static __inline__ int radeon_check_and_fixup_packets(drm_radeon_private_t *
                 }
                 break;
 
+        case R200_EMIT_VAP_CTL:{
+                        RING_LOCALS;
+                        BEGIN_RING(2);
+                        OUT_RING_REG(RADEON_SE_TCL_STATE_FLUSH, 0);
+                        ADVANCE_RING();
+                }
+                break;
+
         case RADEON_EMIT_RB3D_COLORPITCH:
         case RADEON_EMIT_RE_LINE_PATTERN:
         case RADEON_EMIT_SE_LINE_WIDTH:
@@ -202,7 +210,6 @@ static __inline__ int radeon_check_and_fixup_packets(drm_radeon_private_t *
         case R200_EMIT_TCL_LIGHT_MODEL_CTL_0:
         case R200_EMIT_TFACTOR_0:
         case R200_EMIT_VTX_FMT_0:
-        case R200_EMIT_VAP_CTL:
         case R200_EMIT_MATRIX_SELECT_0:
         case R200_EMIT_TEX_PROC_CTL_2:
         case R200_EMIT_TCL_UCP_VERT_BLEND_CTL:
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 0aa5d608fe6f..843d34c8627c 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -3428,6 +3428,7 @@ struct ipmi_recv_msg *ipmi_alloc_recv_msg(void)
 
         rv = kmalloc(sizeof(struct ipmi_recv_msg), GFP_ATOMIC);
         if (rv) {
+                rv->user = NULL;
                 rv->done = free_recv_msg;
                 atomic_inc(&recv_msg_inuse_count);
         }
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index b2dbbdb1bf81..2f07b085536b 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -391,8 +391,8 @@ static MGSL_PARAMS default_params = {
 #define DESC_LIST_SIZE 4096
 
 #define MASK_PARITY  BIT1
-#define MASK_FRAMING BIT2
-#define MASK_BREAK   BIT3
+#define MASK_FRAMING BIT0
+#define MASK_BREAK   BIT14
 #define MASK_OVERRUN BIT4
 
 #define GSR   0x00 /* global status */
@@ -1800,17 +1800,17 @@ static void rx_async(struct slgt_info *info)
 
                         stat = 0;
 
-                        if ((status = *(p+1) & (BIT9 + BIT8))) {
-                                if (status & BIT9)
+                        if ((status = *(p+1) & (BIT1 + BIT0))) {
+                                if (status & BIT1)
                                         icount->parity++;
-                                else if (status & BIT8)
+                                else if (status & BIT0)
                                         icount->frame++;
                                 /* discard char if tty control flags say so */
                                 if (status & info->ignore_status_mask)
                                         continue;
-                                if (status & BIT9)
+                                if (status & BIT1)
                                         stat = TTY_PARITY;
-                                else if (status & BIT8)
+                                else if (status & BIT0)
                                         stat = TTY_FRAME;
                         }
                         if (tty) {
diff --git a/drivers/char/watchdog/sbc8360.c b/drivers/char/watchdog/sbc8360.c
index 1035be5b5019..41fc6f80c493 100644
--- a/drivers/char/watchdog/sbc8360.c
+++ b/drivers/char/watchdog/sbc8360.c
@@ -200,7 +200,7 @@ static int wd_margin = 0xB;
 static int wd_multiplier = 2;
 static int nowayout = WATCHDOG_NOWAYOUT;
 
-module_param(timeout, int, 27);
+module_param(timeout, int, 0);
 MODULE_PARM_DESC(timeout, "Index into timeout table (0-63) (default=27 (60s))");
 module_param(nowayout, int, 0);
 MODULE_PARM_DESC(nowayout,
@@ -407,7 +407,7 @@ module_exit(sbc8360_exit);
 MODULE_AUTHOR("Ian E. Morgan <imorgan@webcon.ca>");
 MODULE_DESCRIPTION("SBC8360 watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_VERSION("1.0");
+MODULE_VERSION("1.01");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 /* end of sbc8360.c */
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index e125032bb403..d8a0d87df734 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -367,12 +367,13 @@ sgiioc4_INB(unsigned long port)
 static void __devinit
 ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
 {
+        void __iomem *virt_dma_base;
         int num_ports = sizeof (ioc4_dma_regs_t);
 
         printk(KERN_INFO "%s: BM-DMA at 0x%04lx-0x%04lx\n", hwif->name,
                dma_base, dma_base + num_ports - 1);
 
-        if (!request_region(dma_base, num_ports, hwif->name)) {
+        if (!request_mem_region(dma_base, num_ports, hwif->name)) {
                 printk(KERN_ERR
                        "%s(%s) -- ERROR, Addresses 0x%p to 0x%p "
                        "ALREADY in use\n",
@@ -381,13 +382,21 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
                 goto dma_alloc_failure;
         }
 
-        hwif->dma_base = dma_base;
+        virt_dma_base = ioremap(dma_base, num_ports);
+        if (virt_dma_base == NULL) {
+                printk(KERN_ERR
+                       "%s(%s) -- ERROR, Unable to map addresses 0x%lx to 0x%lx\n",
+                       __FUNCTION__, hwif->name, dma_base, dma_base + num_ports - 1);
+                goto dma_remap_failure;
+        }
+        hwif->dma_base = (unsigned long) virt_dma_base;
+
         hwif->dmatable_cpu = pci_alloc_consistent(hwif->pci_dev,
                                           IOC4_PRD_ENTRIES * IOC4_PRD_BYTES,
                                           &hwif->dmatable_dma);
 
         if (!hwif->dmatable_cpu)
-                goto dma_alloc_failure;
+                goto dma_pci_alloc_failure;
 
         hwif->sg_max_nents = IOC4_PRD_ENTRIES;
 
@@ -411,6 +420,12 @@ dma_base2alloc_failure:
         printk(KERN_INFO
                "Changing from DMA to PIO mode for Drive %s\n", hwif->name);
 
+dma_pci_alloc_failure:
+        iounmap(virt_dma_base);
+
+dma_remap_failure:
+        release_mem_region(dma_base, num_ports);
+
 dma_alloc_failure:
         /* Disable DMA because we couldnot allocate any DMA maps */
         hwif->autodma = 0;
@@ -607,18 +622,15 @@ ide_init_sgiioc4(ide_hwif_t * hwif)
         hwif->ide_dma_lostirq = &sgiioc4_ide_dma_lostirq;
         hwif->ide_dma_timeout = &__ide_dma_timeout;
 
-        /*
-         * The IOC4 uses MMIO rather than Port IO.
-         * It also needs special workarounds for INB.
-         */
-        default_hwif_mmiops(hwif);
         hwif->INB = &sgiioc4_INB;
 }
 
 static int __devinit
 sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
 {
-        unsigned long base, ctl, dma_base, irqport;
+        unsigned long cmd_base, dma_base, irqport;
+        unsigned long bar0, cmd_phys_base, ctl;
+        void __iomem *virt_base;
         ide_hwif_t *hwif;
         int h;
 
@@ -636,23 +648,32 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
         }
 
         /*  Get the CmdBlk and CtrlBlk Base Registers */
-        base = pci_resource_start(dev, 0) + IOC4_CMD_OFFSET;
-        ctl = pci_resource_start(dev, 0) + IOC4_CTRL_OFFSET;
-        irqport = pci_resource_start(dev, 0) + IOC4_INTR_OFFSET;
+        bar0 = pci_resource_start(dev, 0);
+        virt_base = ioremap(bar0, pci_resource_len(dev, 0));
+        if (virt_base == NULL) {
+                printk(KERN_ERR "%s: Unable to remap BAR 0 address: 0x%lx\n",
+                        d->name, bar0);
+                return -ENOMEM;
+        }
+        cmd_base = (unsigned long) virt_base + IOC4_CMD_OFFSET;
+        ctl = (unsigned long) virt_base + IOC4_CTRL_OFFSET;
+        irqport = (unsigned long) virt_base + IOC4_INTR_OFFSET;
         dma_base = pci_resource_start(dev, 0) + IOC4_DMA_OFFSET;
 
-        if (!request_region(base, IOC4_CMD_CTL_BLK_SIZE, hwif->name)) {
+        cmd_phys_base = bar0 + IOC4_CMD_OFFSET;
+        if (!request_mem_region(cmd_phys_base, IOC4_CMD_CTL_BLK_SIZE,
+            hwif->name)) {
                 printk(KERN_ERR
-                        "%s : %s -- ERROR, Port Addresses "
+                        "%s : %s -- ERROR, Addresses "
                         "0x%p to 0x%p ALREADY in use\n",
-                       __FUNCTION__, hwif->name, (void *) base,
-                       (void *) base + IOC4_CMD_CTL_BLK_SIZE);
+                       __FUNCTION__, hwif->name, (void *) cmd_phys_base,
+                       (void *) cmd_phys_base + IOC4_CMD_CTL_BLK_SIZE);
                 return -ENOMEM;
         }
 
-        if (hwif->io_ports[IDE_DATA_OFFSET] != base) {
+        if (hwif->io_ports[IDE_DATA_OFFSET] != cmd_base) {
                 /* Initialize the IO registers */
-                sgiioc4_init_hwif_ports(&hwif->hw, base, ctl, irqport);
+                sgiioc4_init_hwif_ports(&hwif->hw, cmd_base, ctl, irqport);
                 memcpy(hwif->io_ports, hwif->hw.io_ports,
                        sizeof (hwif->io_ports));
                 hwif->noprobe = !hwif->io_ports[IDE_DATA_OFFSET];
@@ -665,6 +686,9 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
         hwif->cds = (struct ide_pci_device_s *) d;
         hwif->gendev.parent = &dev->dev;/* setup proper ancestral information */
 
+        /* The IOC4 uses MMIO rather than Port IO. */
+        default_hwif_mmiops(hwif);
+
         /* Initializing chipset IRQ Registers */
         hwif->OUTL(0x03, irqport + IOC4_INTR_SET * 4);
 
diff --git a/drivers/ide/pci/via82cxxx.c b/drivers/ide/pci/via82cxxx.c
index afdaee3c15c9..9b7589e8e93e 100644
--- a/drivers/ide/pci/via82cxxx.c
+++ b/drivers/ide/pci/via82cxxx.c
@@ -6,7 +6,7 @@
  *
  *   vt82c576, vt82c586, vt82c586a, vt82c586b, vt82c596a, vt82c596b,
  *   vt82c686, vt82c686a, vt82c686b, vt8231, vt8233, vt8233c, vt8233a,
- *   vt8235, vt8237
+ *   vt8235, vt8237, vt8237a
  *
  * Copyright (c) 2000-2002 Vojtech Pavlik
  *
@@ -81,6 +81,7 @@ static struct via_isa_bridge {
         { "vt6410",     PCI_DEVICE_ID_VIA_6410,     0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
         { "vt8251",     PCI_DEVICE_ID_VIA_8251,     0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
         { "vt8237",     PCI_DEVICE_ID_VIA_8237,     0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
+        { "vt8237a",    PCI_DEVICE_ID_VIA_8237A,    0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
         { "vt8235",     PCI_DEVICE_ID_VIA_8235,     0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
         { "vt8233a",    PCI_DEVICE_ID_VIA_8233A,    0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
         { "vt8233c",    PCI_DEVICE_ID_VIA_8233C_0,  0x00, 0x2f, VIA_UDMA_100 },
diff --git a/drivers/infiniband/hw/mthca/mthca_allocator.c b/drivers/infiniband/hw/mthca/mthca_allocator.c
index 25157f57a6d0..f930e55b58fc 100644
--- a/drivers/infiniband/hw/mthca/mthca_allocator.c
+++ b/drivers/infiniband/hw/mthca/mthca_allocator.c
@@ -41,9 +41,11 @@
 /* Trivial bitmap-based allocator */
 u32 mthca_alloc(struct mthca_alloc *alloc)
 {
+        unsigned long flags;
         u32 obj;
 
-        spin_lock(&alloc->lock);
+        spin_lock_irqsave(&alloc->lock, flags);
+
         obj = find_next_zero_bit(alloc->table, alloc->max, alloc->last);
         if (obj >= alloc->max) {
                 alloc->top = (alloc->top + alloc->max) & alloc->mask;
@@ -56,19 +58,24 @@ u32 mthca_alloc(struct mthca_alloc *alloc)
         } else
                 obj = -1;
 
-        spin_unlock(&alloc->lock);
+        spin_unlock_irqrestore(&alloc->lock, flags);
 
         return obj;
 }
 
 void mthca_free(struct mthca_alloc *alloc, u32 obj)
 {
+        unsigned long flags;
+
         obj &= alloc->max - 1;
-        spin_lock(&alloc->lock);
+
+        spin_lock_irqsave(&alloc->lock, flags);
+
         clear_bit(obj, alloc->table);
         alloc->last = min(alloc->last, obj);
         alloc->top = (alloc->top + alloc->max) & alloc->mask;
-        spin_unlock(&alloc->lock);
+
+        spin_unlock_irqrestore(&alloc->lock, flags);
 }
 
 int mthca_alloc_init(struct mthca_alloc *alloc, u32 num, u32 mask,
diff --git a/drivers/macintosh/via-pmu-backlight.c b/drivers/macintosh/via-pmu-backlight.c
index d3f8d75bcbb4..a82f313d9dc9 100644
--- a/drivers/macintosh/via-pmu-backlight.c
+++ b/drivers/macintosh/via-pmu-backlight.c
@@ -18,17 +18,48 @@
 static struct backlight_properties pmu_backlight_data;
 static spinlock_t pmu_backlight_lock;
 static int sleeping;
+static u8 bl_curve[FB_BACKLIGHT_LEVELS];
 
-static int pmu_backlight_get_level_brightness(struct fb_info *info,
-                int level)
+static void pmu_backlight_init_curve(u8 off, u8 min, u8 max)
+{
+        unsigned int i, flat, count, range = (max - min);
+
+        bl_curve[0] = off;
+
+        for (flat = 1; flat < (FB_BACKLIGHT_LEVELS / 16); ++flat)
+                bl_curve[flat] = min;
+
+        count = FB_BACKLIGHT_LEVELS * 15 / 16;
+        for (i = 0; i < count; ++i)
+                bl_curve[flat + i] = min + (range * (i + 1) / count);
+}
+
+static int pmu_backlight_curve_lookup(int value)
+{
+        int level = (FB_BACKLIGHT_LEVELS - 1);
+        int i, max = 0;
+
+        /* Look for biggest value */
+        for (i = 0; i < FB_BACKLIGHT_LEVELS; i++)
+                max = max((int)bl_curve[i], max);
+
+        /* Look for nearest value */
+        for (i = 0; i < FB_BACKLIGHT_LEVELS; i++) {
+                int diff = abs(bl_curve[i] - value);
+                if (diff < max) {
+                        max = diff;
+                        level = i;
+                }
+        }
+        return level;
+}
+
+static int pmu_backlight_get_level_brightness(int level)
 {
         int pmulevel;
 
         /* Get and convert the value */
-        mutex_lock(&info->bl_mutex);
-        pmulevel = info->bl_curve[level] * FB_BACKLIGHT_MAX / MAX_PMU_LEVEL;
-        mutex_unlock(&info->bl_mutex);
-
+        pmulevel = bl_curve[level] * FB_BACKLIGHT_MAX / MAX_PMU_LEVEL;
         if (pmulevel < 0)
                 pmulevel = 0;
         else if (pmulevel > MAX_PMU_LEVEL)
@@ -39,7 +70,6 @@ static int pmu_backlight_get_level_brightness(struct fb_info *info,
 
 static int pmu_backlight_update_status(struct backlight_device *bd)
 {
-        struct fb_info *info = class_get_devdata(&bd->class_dev);
         struct adb_request req;
         unsigned long flags;
         int level = bd->props->brightness;
@@ -55,7 +85,7 @@ static int pmu_backlight_update_status(struct backlight_device *bd)
                 level = 0;
 
         if (level > 0) {
-                int pmulevel = pmu_backlight_get_level_brightness(info, level);
+                int pmulevel = pmu_backlight_get_level_brightness(level);
 
                 pmu_request(&req, NULL, 2, PMU_BACKLIGHT_BRIGHT, pmulevel);
                 pmu_wait_complete(&req);
@@ -88,35 +118,19 @@ static struct backlight_properties pmu_backlight_data = {
 };
 
 #ifdef CONFIG_PM
-static int pmu_backlight_sleep_call(struct pmu_sleep_notifier *self, int when)
+void pmu_backlight_set_sleep(int sleep)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&pmu_backlight_lock, flags);
-
-        switch (when) {
-        case PBOOK_SLEEP_REQUEST:
-                sleeping = 1;
-                break;
-        case PBOOK_WAKE:
-                sleeping = 0;
-                break;
-        }
-
+        sleeping = sleep;
         spin_unlock_irqrestore(&pmu_backlight_lock, flags);
-
-        return PBOOK_SLEEP_OK;
 }
-
-static struct pmu_sleep_notifier pmu_backlight_sleep_notif = {
-        .notifier_call = pmu_backlight_sleep_call,
-};
-#endif
+#endif /* CONFIG_PM */
 
 void __init pmu_backlight_init()
 {
         struct backlight_device *bd;
-        struct fb_info *info;
         char name[10];
         int level, autosave;
 
@@ -131,27 +145,14 @@ void __init pmu_backlight_init()
             !machine_is_compatible("PowerBook1,1"))
                 return;
 
-        /* Actually, this is a hack, but I don't know of a better way
-         * to get the first framebuffer device.
-         */
-        info = registered_fb[0];
-        if (!info) {
-                printk("pmubl: No framebuffer found\n");
-                goto error;
-        }
-
-        snprintf(name, sizeof(name), "pmubl%d", info->node);
+        snprintf(name, sizeof(name), "pmubl");
 
-        bd = backlight_device_register(name, info, &pmu_backlight_data);
+        bd = backlight_device_register(name, NULL, &pmu_backlight_data);
         if (IS_ERR(bd)) {
                 printk("pmubl: Backlight registration failed\n");
                 goto error;
         }
-
-        mutex_lock(&info->bl_mutex);
-        info->bl_dev = bd;
-        fb_bl_default_curve(info, 0x7F, 0x46, 0x0E);
-        mutex_unlock(&info->bl_mutex);
+        pmu_backlight_init_curve(0x7F, 0x46, 0x0E);
 
         level = pmu_backlight_data.max_brightness;
 
@@ -161,28 +162,22 @@ void __init pmu_backlight_init()
                 pmu_request(&req, NULL, 2, 0xd9, 0);
                 pmu_wait_complete(&req);
 
-                mutex_lock(&info->bl_mutex);
-                level = pmac_backlight_curve_lookup(info,
+                level = pmu_backlight_curve_lookup(
                                 (req.reply[0] >> 4) *
                                 pmu_backlight_data.max_brightness / 15);
-                mutex_unlock(&info->bl_mutex);
         }
 
-        up(&bd->sem);
+        down(&bd->sem);
         bd->props->brightness = level;
         bd->props->power = FB_BLANK_UNBLANK;
         bd->props->update_status(bd);
-        down(&bd->sem);
+        up(&bd->sem);
 
         mutex_lock(&pmac_backlight_mutex);
         if (!pmac_backlight)
                 pmac_backlight = bd;
         mutex_unlock(&pmac_backlight_mutex);
 
-#ifdef CONFIG_PM
-        pmu_register_sleep_notifier(&pmu_backlight_sleep_notif);
-#endif
-
         printk("pmubl: Backlight initialized (%s)\n", name);
 
         return;
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index ea386801e215..14610a63f580 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -1995,6 +1995,8 @@ restore_via_state(void)
         out_8(&via[IER], IER_SET | SR_INT | CB1_INT);
 }
 
+extern void pmu_backlight_set_sleep(int sleep);
+
 static int
 pmac_suspend_devices(void)
 {
@@ -2032,6 +2034,11 @@ pmac_suspend_devices(void)
                 return -EBUSY;
         }
 
+#ifdef CONFIG_PMAC_BACKLIGHT
+        /* Tell backlight code not to muck around with the chip anymore */
+        pmu_backlight_set_sleep(1);
+#endif
+
         /* Call platform functions marked "on sleep" */
         pmac_pfunc_i2c_suspend();
         pmac_pfunc_base_suspend();
@@ -2090,6 +2097,11 @@ pmac_wakeup_devices(void)
 {
         mdelay(100);
 
+#ifdef CONFIG_PMAC_BACKLIGHT
+        /* Tell backlight code it can use the chip again */
+        pmu_backlight_set_sleep(0);
+#endif
+
         /* Power back up system devices (including the PIC) */
         device_power_up();
 
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 87bfe9e7d8ca..3b4d69c05623 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -930,10 +930,13 @@ static void status(struct seq_file *seq, mddev_t *mddev)
 
         seq_printf(seq, " [%d/%d] [", conf->raid_disks,
                                                 conf->working_disks);
-        for (i = 0; i < conf->raid_disks; i++)
+        rcu_read_lock();
+        for (i = 0; i < conf->raid_disks; i++) {
+                mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
                 seq_printf(seq, "%s",
-                              conf->mirrors[i].rdev &&
-                              test_bit(In_sync, &conf->mirrors[i].rdev->flags) ? "U" : "_");
+                           rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
+        }
+        rcu_read_unlock();
         seq_printf(seq, "]");
 }
 
@@ -975,7 +978,6 @@ static void error(mddev_t *mddev, mdk_rdev_t *rdev)
 static void print_conf(conf_t *conf)
 {
         int i;
-        mirror_info_t *tmp;
 
         printk("RAID1 conf printout:\n");
         if (!conf) {
@@ -985,14 +987,17 @@ static void print_conf(conf_t *conf)
         printk(" --- wd:%d rd:%d\n", conf->working_disks,
                 conf->raid_disks);
 
+        rcu_read_lock();
         for (i = 0; i < conf->raid_disks; i++) {
                 char b[BDEVNAME_SIZE];
-                tmp = conf->mirrors + i;
-                if (tmp->rdev)
+                mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
+                if (rdev)
                         printk(" disk %d, wo:%d, o:%d, dev:%s\n",
-                                i, !test_bit(In_sync, &tmp->rdev->flags), !test_bit(Faulty, &tmp->rdev->flags),
-                                bdevname(tmp->rdev->bdev,b));
+                               i, !test_bit(In_sync, &rdev->flags),
+                               !test_bit(Faulty, &rdev->flags),
+                               bdevname(rdev->bdev,b));
         }
+        rcu_read_unlock();
 }
 
 static void close_sync(conf_t *conf)
@@ -1008,20 +1013,20 @@ static int raid1_spare_active(mddev_t *mddev)
 {
         int i;
         conf_t *conf = mddev->private;
-        mirror_info_t *tmp;
 
         /*
          * Find all failed disks within the RAID1 configuration 
-         * and mark them readable
+         * and mark them readable.
+         * Called under mddev lock, so rcu protection not needed.
          */
         for (i = 0; i < conf->raid_disks; i++) {
-                tmp = conf->mirrors + i;
-                if (tmp->rdev 
-                    && !test_bit(Faulty, &tmp->rdev->flags)
-                    && !test_bit(In_sync, &tmp->rdev->flags)) {
+                mdk_rdev_t *rdev = conf->mirrors[i].rdev;
+                if (rdev
+                    && !test_bit(Faulty, &rdev->flags)
+                    && !test_bit(In_sync, &rdev->flags)) {
                         conf->working_disks++;
                         mddev->degraded--;
-                        set_bit(In_sync, &tmp->rdev->flags);
+                        set_bit(In_sync, &rdev->flags);
                 }
         }
 
@@ -1237,7 +1242,7 @@ static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
                 /* ouch - failed to read all of that.
                  * Try some synchronous reads of other devices to get
                  * good data, much like with normal read errors.  Only
-                 * read into the pages we already have so they we don't
+                 * read into the pages we already have so we don't
                  * need to re-issue the read request.
                  * We don't need to freeze the array, because being in an
                  * active sync request, there is no normal IO, and
@@ -1257,6 +1262,10 @@ static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
                                 s = PAGE_SIZE >> 9;
                         do {
                                 if (r1_bio->bios[d]->bi_end_io == end_sync_read) {
+                                        /* No rcu protection needed here devices
+                                         * can only be removed when no resync is
+                                         * active, and resync is currently active
+                                         */
                                         rdev = conf->mirrors[d].rdev;
                                         if (sync_page_io(rdev->bdev,
                                                          sect + rdev->data_offset,
@@ -1463,6 +1472,11 @@ static void raid1d(mddev_t *mddev)
                                         s = PAGE_SIZE >> 9;
 
                                 do {
+                                        /* Note: no rcu protection needed here
+                                         * as this is synchronous in the raid1d thread
+                                         * which is the thread that might remove
+                                         * a device.  If raid1d ever becomes multi-threaded....
+                                         */
                                         rdev = conf->mirrors[d].rdev;
                                         if (rdev &&
                                             test_bit(In_sync, &rdev->flags) &&
@@ -1486,7 +1500,6 @@ static void raid1d(mddev_t *mddev)
                                                         d = conf->raid_disks;
                                                 d--;
                                                 rdev = conf->mirrors[d].rdev;
-                                                atomic_add(s, &rdev->corrected_errors);
                                                 if (rdev &&
                                                     test_bit(In_sync, &rdev->flags)) {
                                                         if (sync_page_io(rdev->bdev,
@@ -1509,9 +1522,11 @@ static void raid1d(mddev_t *mddev)
                                                                          s<<9, conf->tmppage, READ) == 0)
                                                                 /* Well, this device is dead */
                                                                 md_error(mddev, rdev);
-                                                        else
+                                                        else {
+                                                                atomic_add(s, &rdev->corrected_errors);
                                                                 printk(KERN_INFO "raid1:%s: read error corrected (%d sectors at %llu on %s)\n",
                                                                        mdname(mddev), s, (unsigned long long)(sect + rdev->data_offset), bdevname(rdev->bdev, b));
+                                                        }
                                                 }
                                         }
                                 } else {
@@ -1787,19 +1802,17 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
                 for (i=0; i<conf->raid_disks; i++) {
                         bio = r1_bio->bios[i];
                         if (bio->bi_end_io == end_sync_read) {
-                                md_sync_acct(conf->mirrors[i].rdev->bdev, nr_sectors);
+                                md_sync_acct(bio->bi_bdev, nr_sectors);
                                 generic_make_request(bio);
                         }
                 }
         } else {
                 atomic_set(&r1_bio->remaining, 1);
                 bio = r1_bio->bios[r1_bio->read_disk];
-                md_sync_acct(conf->mirrors[r1_bio->read_disk].rdev->bdev,
-                             nr_sectors);
+                md_sync_acct(bio->bi_bdev, nr_sectors);
                 generic_make_request(bio);
 
         }
-
         return nr_sectors;
 }
 
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index 91ef5f2fd768..ce850f1078b5 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -173,8 +173,11 @@ MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
 static int debug = 3;
+static int eeprom_bad_csum_allow = 0;
 module_param(debug, int, 0);
+module_param(eeprom_bad_csum_allow, int, 0);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
+MODULE_PARM_DESC(eeprom_bad_csum_allow, "Allow bad eeprom checksums");
 #define DPRINTK(nlevel, klevel, fmt, args...) \
         (void)((NETIF_MSG_##nlevel & nic->msg_enable) && \
         printk(KERN_##klevel PFX "%s: %s: " fmt, nic->netdev->name, \
@@ -756,7 +759,8 @@ static int e100_eeprom_load(struct nic *nic)
         checksum = le16_to_cpu(0xBABA - checksum);
         if(checksum != nic->eeprom[nic->eeprom_wc - 1]) {
                 DPRINTK(PROBE, ERR, "EEPROM corrupted\n");
-                return -EAGAIN;
+                if (!eeprom_bad_csum_allow)
+                        return -EAGAIN;
         }
 
         return 0;
diff --git a/drivers/net/sunlance.c b/drivers/net/sunlance.c
index 0e3fdf7c6dd3..ec0413609f36 100644
--- a/drivers/net/sunlance.c
+++ b/drivers/net/sunlance.c
@@ -1566,20 +1566,21 @@ static int __exit sunlance_sun4_remove(void)
 static int __devinit sunlance_sbus_probe(struct of_device *dev, const struct of_device_id *match)
 {
         struct sbus_dev *sdev = to_sbus_device(&dev->dev);
-        struct device_node *dp = dev->node;
         int err;
 
-        if (!strcmp(dp->name, "le")) {
-                err = sparc_lance_probe_one(sdev, NULL, NULL);
-        } else if (!strcmp(dp->name, "ledma")) {
-                struct sbus_dma *ledma = find_ledma(sdev);
+        if (sdev->parent) {
+                struct of_device *parent = &sdev->parent->ofdev;
 
-                err = sparc_lance_probe_one(sdev->child, ledma, NULL);
-        } else {
-                BUG_ON(strcmp(dp->name, "lebuffer"));
+                if (!strcmp(parent->node->name, "ledma")) {
+                        struct sbus_dma *ledma = find_ledma(to_sbus_device(&parent->dev));
 
-                err = sparc_lance_probe_one(sdev->child, NULL, sdev);
-        }
+                        err = sparc_lance_probe_one(sdev, ledma, NULL);
+                } else if (!strcmp(parent->node->name, "lebuffer")) {
+                        err = sparc_lance_probe_one(sdev, NULL, to_sbus_device(&parent->dev));
+                } else
+                        err = sparc_lance_probe_one(sdev, NULL, NULL);
+        } else
+                err = sparc_lance_probe_one(sdev, NULL, NULL);
 
         return err;
 }
@@ -1604,12 +1605,6 @@ static struct of_device_id sunlance_sbus_match[] = {
         {
                 .name = "le",
         },
-        {
-                .name = "ledma",
-        },
-        {
-                .name = "lebuffer",
-        },
         {},
 };
 
diff --git a/drivers/net/wireless/strip.c b/drivers/net/wireless/strip.c
index fd31885c6844..ccaf28e8db0a 100644
--- a/drivers/net/wireless/strip.c
+++ b/drivers/net/wireless/strip.c
@@ -467,6 +467,7 @@ static int arp_query(unsigned char *haddr, u32 paddr,
                      struct net_device *dev)
 {
         struct neighbour *neighbor_entry;
+        int ret = 0;
 
         neighbor_entry = neigh_lookup(&arp_tbl, &paddr, dev);
 
@@ -474,10 +475,11 @@ static int arp_query(unsigned char *haddr, u32 paddr,
                 neighbor_entry->used = jiffies;
                 if (neighbor_entry->nud_state & NUD_VALID) {
                         memcpy(haddr, neighbor_entry->ha, dev->addr_len);
-                        return 1;
+                        ret = 1;
                 }
+                neigh_release(neighbor_entry);
         }
-        return 0;
+        return ret;
 }
 
 static void DumpData(char *msg, struct strip *strip_info, __u8 * ptr,
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 73177429fe74..17e709e7d72a 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -667,6 +667,7 @@ DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_0, quirk_vi
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_1, quirk_via_irq);
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_2, quirk_via_irq);
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_3, quirk_via_irq);
+DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235_USB_2, quirk_via_irq);
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686, quirk_via_irq);
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4, quirk_via_irq);
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_5, quirk_via_irq);
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index d8e9b95f0a1a..25c1ef6dfd44 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -52,7 +52,7 @@ static void dasd_setup_queue(struct dasd_device * device);
 static void dasd_free_queue(struct dasd_device * device);
 static void dasd_flush_request_queue(struct dasd_device *);
 static void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *);
-static void dasd_flush_ccw_queue(struct dasd_device *, int);
+static int dasd_flush_ccw_queue(struct dasd_device *, int);
 static void dasd_tasklet(struct dasd_device *);
 static void do_kick_device(void *data);
 
@@ -60,6 +60,7 @@ static void do_kick_device(void *data);
  * SECTION: Operations on the device structure.
  */
 static wait_queue_head_t dasd_init_waitq;
+static wait_queue_head_t dasd_flush_wq;
 
 /*
  * Allocate memory for a new device structure.
@@ -121,7 +122,7 @@ dasd_free_device(struct dasd_device *device)
 /*
  * Make a new device known to the system.
  */
-static inline int
+static int
 dasd_state_new_to_known(struct dasd_device *device)
 {
         int rc;
@@ -145,7 +146,7 @@ dasd_state_new_to_known(struct dasd_device *device)
 /*
  * Let the system forget about a device.
  */
-static inline void
+static int
 dasd_state_known_to_new(struct dasd_device * device)
 {
         /* Disable extended error reporting for this device. */
@@ -163,12 +164,13 @@ dasd_state_known_to_new(struct dasd_device * device)
 
         /* Give up reference we took in dasd_state_new_to_known. */
         dasd_put_device(device);
+        return 0;
 }
 
 /*
  * Request the irq line for the device.
  */
-static inline int
+static int
 dasd_state_known_to_basic(struct dasd_device * device)
 {
         int rc;
@@ -192,17 +194,23 @@ dasd_state_known_to_basic(struct dasd_device * device)
 /*
  * Release the irq line for the device. Terminate any running i/o.
  */
-static inline void
+static int
 dasd_state_basic_to_known(struct dasd_device * device)
 {
+        int rc;
+
         dasd_gendisk_free(device);
-        dasd_flush_ccw_queue(device, 1);
+        rc = dasd_flush_ccw_queue(device, 1);
+        if (rc)
+                return rc;
+
         DBF_DEV_EVENT(DBF_EMERG, device, "%p debug area deleted", device);
         if (device->debug_area != NULL) {
                 debug_unregister(device->debug_area);
                 device->debug_area = NULL;
         }
         device->state = DASD_STATE_KNOWN;
+        return 0;
 }
 
 /*
@@ -219,7 +227,7 @@ dasd_state_basic_to_known(struct dasd_device * device)
  * In case the analysis returns an error, the device setup is stopped
  * (a fake disk was already added to allow formatting).
  */
-static inline int
+static int
 dasd_state_basic_to_ready(struct dasd_device * device)
 {
         int rc;
@@ -247,25 +255,31 @@ dasd_state_basic_to_ready(struct dasd_device * device)
  * Forget format information. Check if the target level is basic
  * and if it is create fake disk for formatting.
  */
-static inline void
+static int
 dasd_state_ready_to_basic(struct dasd_device * device)
 {
-        dasd_flush_ccw_queue(device, 0);
+        int rc;
+
+        rc = dasd_flush_ccw_queue(device, 0);
+        if (rc)
+                return rc;
         dasd_destroy_partitions(device);
         dasd_flush_request_queue(device);
         device->blocks = 0;
         device->bp_block = 0;
         device->s2b_shift = 0;
         device->state = DASD_STATE_BASIC;
+        return 0;
 }
 
 /*
  * Back to basic.
  */
-static inline void
+static int
 dasd_state_unfmt_to_basic(struct dasd_device * device)
 {
         device->state = DASD_STATE_BASIC;
+        return 0;
 }
 
 /*
@@ -273,7 +287,7 @@ dasd_state_unfmt_to_basic(struct dasd_device * device)
  * the requeueing of requests from the linux request queue to the
  * ccw queue.
  */
-static inline int
+static int
 dasd_state_ready_to_online(struct dasd_device * device)
 {
         device->state = DASD_STATE_ONLINE;
@@ -284,16 +298,17 @@ dasd_state_ready_to_online(struct dasd_device * device)
 /*
  * Stop the requeueing of requests again.
  */
-static inline void
+static int
 dasd_state_online_to_ready(struct dasd_device * device)
 {
         device->state = DASD_STATE_READY;
+        return 0;
 }
 
 /*
  * Device startup state changes.
  */
-static inline int
+static int
 dasd_increase_state(struct dasd_device *device)
 {
         int rc;
@@ -329,30 +344,37 @@ dasd_increase_state(struct dasd_device *device)
 /*
  * Device shutdown state changes.
  */
-static inline int
+static int
 dasd_decrease_state(struct dasd_device *device)
 {
+        int rc;
+
+        rc = 0;
         if (device->state == DASD_STATE_ONLINE &&
             device->target <= DASD_STATE_READY)
-                dasd_state_online_to_ready(device);
+                rc = dasd_state_online_to_ready(device);
 
-        if (device->state == DASD_STATE_READY &&
+        if (!rc &&
+            device->state == DASD_STATE_READY &&
             device->target <= DASD_STATE_BASIC)
-                dasd_state_ready_to_basic(device);
+                rc = dasd_state_ready_to_basic(device);
 
-        if (device->state == DASD_STATE_UNFMT &&
+        if (!rc &&
+            device->state == DASD_STATE_UNFMT &&
             device->target <= DASD_STATE_BASIC)
-                dasd_state_unfmt_to_basic(device);
+                rc = dasd_state_unfmt_to_basic(device);
 
-        if (device->state == DASD_STATE_BASIC &&
+        if (!rc &&
+            device->state == DASD_STATE_BASIC &&
             device->target <= DASD_STATE_KNOWN)
-                dasd_state_basic_to_known(device);
+                rc = dasd_state_basic_to_known(device);
 
-        if (device->state == DASD_STATE_KNOWN &&
+        if (!rc &&
+            device->state == DASD_STATE_KNOWN &&
             device->target <= DASD_STATE_NEW)
-                dasd_state_known_to_new(device);
+                rc = dasd_state_known_to_new(device);
 
-        return 0;
+        return rc;
 }
 
 /*
@@ -701,6 +723,7 @@ dasd_term_IO(struct dasd_ccw_req * cqr)
                         cqr->retries--;
                         cqr->status = DASD_CQR_CLEAR;
                         cqr->stopclk = get_clock();
+                        cqr->starttime = 0;
                         DBF_DEV_EVENT(DBF_DEBUG, device,
                                       "terminate cqr %p successful",
                                       cqr);
@@ -978,6 +1001,7 @@ dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
             irb->scsw.fctl & SCSW_FCTL_CLEAR_FUNC) {
                 cqr->status = DASD_CQR_QUEUED;
                 dasd_clear_timer(device);
+                wake_up(&dasd_flush_wq);
                 dasd_schedule_bh(device);
                 return;
         }
@@ -1241,6 +1265,10 @@ __dasd_check_expire(struct dasd_device * device)
         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, list);
         if (cqr->status == DASD_CQR_IN_IO && cqr->expires != 0) {
                 if (time_after_eq(jiffies, cqr->expires + cqr->starttime)) {
+                        DEV_MESSAGE(KERN_ERR, device,
+                                    "internal error - timeout (%is) expired "
+                                    "for cqr %p (%i retries left)",
+                                    (cqr->expires/HZ), cqr, cqr->retries);
                         if (device->discipline->term_IO(cqr) != 0)
                                 /* Hmpf, try again in 1/10 sec */
                                 dasd_set_timer(device, 10);
@@ -1285,46 +1313,100 @@ __dasd_start_head(struct dasd_device * device)
                 dasd_set_timer(device, 50);
 }
 
+static inline int
+_wait_for_clear(struct dasd_ccw_req *cqr)
+{
+        return (cqr->status == DASD_CQR_QUEUED);
+}
+
 /*
- * Remove requests from the ccw queue.
+ * Remove all requests from the ccw queue (all = '1') or only block device
+ * requests in case all = '0'.
+ * Take care of the erp-chain (chained via cqr->refers) and remove either
+ * the whole erp-chain or none of the erp-requests.
+ * If a request is currently running, term_IO is called and the request
+ * is re-queued. Prior to removing the terminated request we need to wait
+ * for the clear-interrupt.
+ * In case termination is not possible we stop processing and just finishing
+ * the already moved requests.
  */
-static void
+static int
 dasd_flush_ccw_queue(struct dasd_device * device, int all)
 {
+        struct dasd_ccw_req *cqr, *orig, *n;
+        int rc, i;
+
         struct list_head flush_queue;
-        struct list_head *l, *n;
-        struct dasd_ccw_req *cqr;
 
         INIT_LIST_HEAD(&flush_queue);
         spin_lock_irq(get_ccwdev_lock(device->cdev));
-        list_for_each_safe(l, n, &device->ccw_queue) {
-                cqr = list_entry(l, struct dasd_ccw_req, list);
+        rc = 0;
+restart:
+        list_for_each_entry_safe(cqr, n, &device->ccw_queue, list) {
+                /* get original request of erp request-chain */
+                for (orig = cqr; orig->refers != NULL; orig = orig->refers);
+
                 /* Flush all request or only block device requests? */
-                if (all == 0 && cqr->callback == dasd_end_request_cb)
+                if (all == 0 && cqr->callback != dasd_end_request_cb &&
+                    orig->callback != dasd_end_request_cb) {
                         continue;
-                if (cqr->status == DASD_CQR_IN_IO)
-                        device->discipline->term_IO(cqr);
-                if (cqr->status != DASD_CQR_DONE ||
-                    cqr->status != DASD_CQR_FAILED) {
-                        cqr->status = DASD_CQR_FAILED;
+                }
+                /* Check status and move request to flush_queue */
+                switch (cqr->status) {
+                case DASD_CQR_IN_IO:
+                        rc = device->discipline->term_IO(cqr);
+                        if (rc) {
+                                /* unable to terminate requeust */
+                                DEV_MESSAGE(KERN_ERR, device,
+                                            "dasd flush ccw_queue is unable "
+                                            " to terminate request %p",
+                                            cqr);
+                                /* stop flush processing */
+                                goto finished;
+                        }
+                        break;
+                case DASD_CQR_QUEUED:
+                case DASD_CQR_ERROR:
+                        /* set request to FAILED */
                         cqr->stopclk = get_clock();
+                        cqr->status = DASD_CQR_FAILED;
+                        break;
+                default: /* do not touch the others */
+                        break;
+                }
+                /* Rechain request (including erp chain) */
+                for (i = 0; cqr != NULL; cqr = cqr->refers, i++) {
+                        cqr->endclk = get_clock();
+                        list_move_tail(&cqr->list, &flush_queue);
+                }
+                if (i > 1)
+                        /* moved more than one request - need to restart */
+                        goto restart;
+        }
+
+finished:
+        spin_unlock_irq(get_ccwdev_lock(device->cdev));
+        /* Now call the callback function of flushed requests */
+restart_cb:
+        list_for_each_entry_safe(cqr, n, &flush_queue, list) {
+                if (cqr->status == DASD_CQR_CLEAR) {
+                        /* wait for clear interrupt! */
+                        wait_event(dasd_flush_wq, _wait_for_clear(cqr));
+                        cqr->status = DASD_CQR_FAILED;
                 }
                 /* Process finished ERP request. */
                 if (cqr->refers) {
                         __dasd_process_erp(device, cqr);
-                        continue;
+                        /* restart list_for_xx loop since dasd_process_erp
+                         * might remove multiple elements */
+                        goto restart_cb;
                 }
-                /* Rechain request on device request queue */
+                /* call the callback function */
                 cqr->endclk = get_clock();
-                list_move_tail(&cqr->list, &flush_queue);
-        }
-        spin_unlock_irq(get_ccwdev_lock(device->cdev));
-        /* Now call the callback function of flushed requests */
-        list_for_each_safe(l, n, &flush_queue) {
-                cqr = list_entry(l, struct dasd_ccw_req, list);
                 if (cqr->callback != NULL)
                         (cqr->callback)(cqr, cqr->callback_data);
         }
+        return rc;
 }
 
 /*
@@ -1510,10 +1592,8 @@ dasd_sleep_on_interruptible(struct dasd_ccw_req * cqr)
                         if (device->discipline->term_IO) {
                                 cqr->retries = -1;
                                 device->discipline->term_IO(cqr);
-                                /*nished =
-                                 * wait (non-interruptible) for final status
-                                 * because signal ist still pending
-                                 */
+                                /* wait (non-interruptible) for final status
+                                 * because signal ist still pending */
                                 spin_unlock_irq(get_ccwdev_lock(device->cdev));
                                 wait_event(wait_q, _wait_for_wakeup(cqr));
                                 spin_lock_irq(get_ccwdev_lock(device->cdev));
@@ -1546,19 +1626,11 @@ static inline int
 _dasd_term_running_cqr(struct dasd_device *device)
 {
         struct dasd_ccw_req *cqr;
-        int rc;
 
         if (list_empty(&device->ccw_queue))
                 return 0;
         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, list);
-        rc = device->discipline->term_IO(cqr);
-        if (rc == 0) {
-                /* termination successful */
-                cqr->status = DASD_CQR_QUEUED;
-                cqr->startclk = cqr->stopclk = 0;
-                cqr->starttime = 0;
-        }
-        return rc;
+        return device->discipline->term_IO(cqr);
 }
 
 int
@@ -1726,10 +1798,7 @@ dasd_flush_request_queue(struct dasd_device * device)
                 return;
 
         spin_lock_irq(&device->request_queue_lock);
-        while (!list_empty(&device->request_queue->queue_head)) {
-                req = elv_next_request(device->request_queue);
-                if (req == NULL)
-                        break;
+        while ((req = elv_next_request(device->request_queue))) {
                 blkdev_dequeue_request(req);
                 dasd_end_request(req, 0);
         }
@@ -2091,6 +2160,7 @@ dasd_init(void)
         int rc;
 
         init_waitqueue_head(&dasd_init_waitq);
+        init_waitqueue_head(&dasd_flush_wq);
 
         /* register 'common' DASD debug area, used for all DBF_XXX calls */
         dasd_debug_area = debug_register("dasd", 1, 2, 8 * sizeof (long));
diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index 4c272b70f41a..d163632101d2 100644
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -83,10 +83,12 @@ dasd_gendisk_alloc(struct dasd_device *device)
 void
 dasd_gendisk_free(struct dasd_device *device)
 {
-        del_gendisk(device->gdp);
-        device->gdp->queue = NULL;
-        put_disk(device->gdp);
-        device->gdp = NULL;
+        if (device->gdp) {
+                del_gendisk(device->gdp);
+                device->gdp->queue = NULL;
+                put_disk(device->gdp);
+                device->gdp = NULL;
+        }
 }
 
 /*
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index 3cba6c9fab11..38954f5cd14c 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -183,11 +183,9 @@ ccwgroup_create(struct device *root,
 
         gdev->creator_id = creator_id;
         gdev->count = argc;
-        gdev->dev = (struct device ) {
-                .bus = &ccwgroup_bus_type,
-                .parent = root,
-                .release = ccwgroup_release,
-        };
+        gdev->dev.bus = &ccwgroup_bus_type;
+        gdev->dev.parent = root;
+        gdev->dev.release = ccwgroup_release;
 
         snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s",
                         gdev->cdev[0]->dev.bus_id);
@@ -391,10 +389,8 @@ int
 ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
 {
         /* register our new driver with the core */
-        cdriver->driver = (struct device_driver) {
-                .bus = &ccwgroup_bus_type,
-                .name = cdriver->name,
-        };
+        cdriver->driver.bus = &ccwgroup_bus_type;
+        cdriver->driver.name = cdriver->name;
 
         return driver_register(&cdriver->driver);
 }
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index 61ce3f1d5228..c28444af0919 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -238,8 +238,6 @@ s390_subchannel_remove_chpid(struct device *dev, void *data)
         /* Check for single path devices. */
         if (sch->schib.pmcw.pim == 0x80)
                 goto out_unreg;
-        if (sch->vpm == mask)
-                goto out_unreg;
 
         if ((sch->schib.scsw.actl & SCSW_ACTL_DEVACT) &&
             (sch->schib.scsw.actl & SCSW_ACTL_SCHACT) &&
@@ -258,6 +256,8 @@ s390_subchannel_remove_chpid(struct device *dev, void *data)
         /* trigger path verification. */
         if (sch->driver && sch->driver->verify)
                 sch->driver->verify(&sch->dev);
+        else if (sch->vpm == mask)
+                goto out_unreg;
 out_unlock:
         spin_unlock_irq(&sch->lock);
         return 0;
@@ -1391,10 +1391,8 @@ new_channel_path(int chpid)
         /* fill in status, etc. */
         chp->id = chpid;
         chp->state = 1;
-        chp->dev = (struct device) {
-                .parent  = &css[0]->device,
-                .release = chp_release,
-        };
+        chp->dev.parent = &css[0]->device;
+        chp->dev.release = chp_release;
         snprintf(chp->dev.bus_id, BUS_ID_SIZE, "chp0.%x", chpid);
 
         /* Obtain channel path description and fill it in. */
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 585fa04233c3..646da5640401 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -556,12 +556,11 @@ get_disc_ccwdev_by_devno(unsigned int devno, unsigned int ssid,
                          struct ccw_device *sibling)
 {
         struct device *dev;
-        struct match_data data = {
-                .devno   = devno,
-                .ssid    = ssid,
-                .sibling = sibling,
-        };
+        struct match_data data;
 
+        data.devno = devno;
+        data.ssid = ssid;
+        data.sibling = sibling;
         dev = bus_find_device(&ccw_bus_type, NULL, &data, match_devno);
 
         return dev ? to_ccwdev(dev) : NULL;
@@ -835,10 +834,8 @@ io_subchannel_probe (struct subchannel *sch)
                 return -ENOMEM;
         }
         atomic_set(&cdev->private->onoff, 0);
-        cdev->dev = (struct device) {
-                .parent = &sch->dev,
-                .release = ccw_device_release,
-        };
+        cdev->dev.parent = &sch->dev;
+        cdev->dev.release = ccw_device_release;
         INIT_LIST_HEAD(&cdev->private->kick_work.entry);
         /* Do first half of device_register. */
         device_initialize(&cdev->dev);
@@ -977,9 +974,7 @@ ccw_device_console_enable (struct ccw_device *cdev, struct subchannel *sch)
         int rc;
 
         /* Initialize the ccw_device structure. */
-        cdev->dev = (struct device) {
-                .parent = &sch->dev,
-        };
+        cdev->dev.parent= &sch->dev;
         rc = io_subchannel_recog(cdev, sch);
         if (rc)
                 return rc;
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index 6d91c2eb205b..35e162ba6d54 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -267,12 +267,10 @@ ccw_device_recog_done(struct ccw_device *cdev, int state)
                         notify = 1;
                 }
                 /* fill out sense information */
-                cdev->id = (struct ccw_device_id) {
-                        .cu_type   = cdev->private->senseid.cu_type,
-                        .cu_model  = cdev->private->senseid.cu_model,
-                        .dev_type  = cdev->private->senseid.dev_type,
-                        .dev_model = cdev->private->senseid.dev_model,
-                };
+                cdev->id.cu_type   = cdev->private->senseid.cu_type;
+                cdev->id.cu_model  = cdev->private->senseid.cu_model;
+                cdev->id.dev_type  = cdev->private->senseid.dev_type;
+                cdev->id.dev_model = cdev->private->senseid.dev_model;
                 if (notify) {
                         cdev->private->state = DEV_STATE_OFFLINE;
                         if (same_dev) {
@@ -566,12 +564,10 @@ ccw_device_verify_done(struct ccw_device *cdev, int err)
                 /* Deliver fake irb to device driver, if needed. */
                 if (cdev->private->flags.fake_irb) {
                         memset(&cdev->private->irb, 0, sizeof(struct irb));
-                        cdev->private->irb.scsw = (struct scsw) {
-                                .cc = 1,
-                                .fctl = SCSW_FCTL_START_FUNC,
-                                .actl = SCSW_ACTL_START_PEND,
-                                .stctl = SCSW_STCTL_STATUS_PEND,
-                        };
+                        cdev->private->irb.scsw.cc = 1;
+                        cdev->private->irb.scsw.fctl = SCSW_FCTL_START_FUNC;
+                        cdev->private->irb.scsw.actl = SCSW_ACTL_START_PEND;
+                        cdev->private->irb.scsw.stctl = SCSW_STCTL_STATUS_PEND;
                         cdev->private->flags.fake_irb = 0;
                         if (cdev->handler)
                                 cdev->handler(cdev, cdev->private->intparm,
diff --git a/drivers/s390/cio/device_pgid.c b/drivers/s390/cio/device_pgid.c
index 32610fd8868e..1693a102dcfe 100644
--- a/drivers/s390/cio/device_pgid.c
+++ b/drivers/s390/cio/device_pgid.c
@@ -24,6 +24,21 @@
 #include "ioasm.h"
 
 /*
+ * Helper function called from interrupt context to decide whether an
+ * operation should be tried again.
+ */
+static int __ccw_device_should_retry(struct scsw *scsw)
+{
+        /* CC is only valid if start function bit is set. */
+        if ((scsw->fctl & SCSW_FCTL_START_FUNC) && scsw->cc == 1)
+                return 1;
+        /* No more activity. For sense and set PGID we stubbornly try again. */
+        if (!scsw->actl)
+                return 1;
+        return 0;
+}
+
+/*
  * Start Sense Path Group ID helper function. Used in ccw_device_recog
  * and ccw_device_sense_pgid.
  */
@@ -155,10 +170,10 @@ ccw_device_sense_pgid_irq(struct ccw_device *cdev, enum dev_event dev_event)
         int ret;
 
         irb = (struct irb *) __LC_IRB;
-        /* Retry sense pgid for cc=1. */
+
         if (irb->scsw.stctl ==
             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
-                if (irb->scsw.cc == 1) {
+                if (__ccw_device_should_retry(&irb->scsw)) {
                         ret = __ccw_device_sense_pgid_start(cdev);
                         if (ret && ret != -EBUSY)
                                 ccw_device_sense_pgid_done(cdev, ret);
@@ -391,10 +406,10 @@ ccw_device_verify_irq(struct ccw_device *cdev, enum dev_event dev_event)
         int ret;
 
         irb = (struct irb *) __LC_IRB;
-        /* Retry set pgid for cc=1. */
+
         if (irb->scsw.stctl ==
             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
-                if (irb->scsw.cc == 1)
+                if (__ccw_device_should_retry(&irb->scsw))
                         __ccw_device_verify_start(cdev);
                 return;
         }
@@ -494,10 +509,10 @@ ccw_device_disband_irq(struct ccw_device *cdev, enum dev_event dev_event)
         int ret;
 
         irb = (struct irb *) __LC_IRB;
-        /* Retry set pgid for cc=1. */
+
         if (irb->scsw.stctl ==
             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
-                if (irb->scsw.cc == 1)
+                if (__ccw_device_should_retry(&irb->scsw))
                         __ccw_device_disband_start(cdev);
                 return;
         }
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index cd1979daf2b8..851e4839d6d9 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -458,11 +458,11 @@ static int pci_siig_setup(struct serial_private *priv,
  * growing *huge*, we use this function to collapse some 70 entries
  * in the PCI table into one, for sanity's and compactness's sake.
  */
-static unsigned short timedia_single_port[] = {
+static const unsigned short timedia_single_port[] = {
         0x4025, 0x4027, 0x4028, 0x5025, 0x5027, 0
 };
 
-static unsigned short timedia_dual_port[] = {
+static const unsigned short timedia_dual_port[] = {
         0x0002, 0x4036, 0x4037, 0x4038, 0x4078, 0x4079, 0x4085,
         0x4088, 0x4089, 0x5037, 0x5078, 0x5079, 0x5085, 0x6079, 
         0x7079, 0x8079, 0x8137, 0x8138, 0x8237, 0x8238, 0x9079, 
@@ -470,35 +470,34 @@ static unsigned short timedia_dual_port[] = {
         0xD079, 0
 };
 
-static unsigned short timedia_quad_port[] = {
+static const unsigned short timedia_quad_port[] = {
         0x4055, 0x4056, 0x4095, 0x4096, 0x5056, 0x8156, 0x8157, 
         0x8256, 0x8257, 0x9056, 0x9156, 0x9157, 0x9158, 0x9159, 
         0x9256, 0x9257, 0xA056, 0xA157, 0xA158, 0xA159, 0xB056,
         0xB157, 0
 };
 
-static unsigned short timedia_eight_port[] = {
+static const unsigned short timedia_eight_port[] = {
         0x4065, 0x4066, 0x5065, 0x5066, 0x8166, 0x9066, 0x9166, 
         0x9167, 0x9168, 0xA066, 0xA167, 0xA168, 0
 };
 
 static const struct timedia_struct {
         int num;
-        unsigned short *ids;
+        const unsigned short *ids;
 } timedia_data[] = {
         { 1, timedia_single_port },
         { 2, timedia_dual_port },
         { 4, timedia_quad_port },
-        { 8, timedia_eight_port },
-        { 0, NULL }
+        { 8, timedia_eight_port }
 };
 
 static int pci_timedia_init(struct pci_dev *dev)
 {
-        unsigned short *ids;
+        const unsigned short *ids;
         int i, j;
 
-        for (i = 0; timedia_data[i].num; i++) {
+        for (i = 0; i < ARRAY_SIZE(timedia_data); i++) {
                 ids = timedia_data[i].ids;
                 for (j = 0; ids[j]; j++)
                         if (dev->subsystem_device == ids[j])
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 80ef7d482756..372e47f7d596 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -2377,6 +2377,9 @@ int uart_match_port(struct uart_port *port1, struct uart_port *port2)
                 return (port1->iobase == port2->iobase) &&
                        (port1->hub6   == port2->hub6);
         case UPIO_MEM:
+        case UPIO_MEM32:
+        case UPIO_AU:
+        case UPIO_TSI:
                 return (port1->mapbase == port2->mapbase);
         }
         return 0;
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 4fe1bec1c255..30299c620d97 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -117,6 +117,8 @@ struct eth_dev {
         struct usb_ep           *in_ep, *out_ep, *status_ep;
         const struct usb_endpoint_descriptor
                                 *in, *out, *status;
+
+        spinlock_t              req_lock;
         struct list_head        tx_reqs, rx_reqs;
 
         struct net_device       *net;
@@ -1066,21 +1068,31 @@ static void eth_reset_config (struct eth_dev *dev)
          */
         if (dev->in) {
                 usb_ep_disable (dev->in_ep);
+                spin_lock(&dev->req_lock);
                 while (likely (!list_empty (&dev->tx_reqs))) {
                         req = container_of (dev->tx_reqs.next,
                                                 struct usb_request, list);
                         list_del (&req->list);
+
+                        spin_unlock(&dev->req_lock);
                         usb_ep_free_request (dev->in_ep, req);
+                        spin_lock(&dev->req_lock);
                 }
+                spin_unlock(&dev->req_lock);
         }
         if (dev->out) {
                 usb_ep_disable (dev->out_ep);
+                spin_lock(&dev->req_lock);
                 while (likely (!list_empty (&dev->rx_reqs))) {
                         req = container_of (dev->rx_reqs.next,
                                                 struct usb_request, list);
                         list_del (&req->list);
+
+                        spin_unlock(&dev->req_lock);
                         usb_ep_free_request (dev->out_ep, req);
+                        spin_lock(&dev->req_lock);
                 }
+                spin_unlock(&dev->req_lock);
         }
 
         if (dev->status) {
@@ -1659,9 +1671,9 @@ enomem:
         if (retval) {
                 DEBUG (dev, "rx submit --> %d\n", retval);
                 dev_kfree_skb_any (skb);
-                spin_lock (&dev->lock);
+                spin_lock(&dev->req_lock);
                 list_add (&req->list, &dev->rx_reqs);
-                spin_unlock (&dev->lock);
+                spin_unlock(&dev->req_lock);
         }
         return retval;
 }
@@ -1730,8 +1742,9 @@ quiesce:
                 dev_kfree_skb_any (skb);
         if (!netif_running (dev->net)) {
 clean:
-                /* nobody reading rx_reqs, so no dev->lock */
+                spin_lock(&dev->req_lock);
                 list_add (&req->list, &dev->rx_reqs);
+                spin_unlock(&dev->req_lock);
                 req = NULL;
         }
         if (req)
@@ -1782,15 +1795,18 @@ static int alloc_requests (struct eth_dev *dev, unsigned n, gfp_t gfp_flags)
 {
         int status;
 
+        spin_lock(&dev->req_lock);
         status = prealloc (&dev->tx_reqs, dev->in_ep, n, gfp_flags);
         if (status < 0)
                 goto fail;
         status = prealloc (&dev->rx_reqs, dev->out_ep, n, gfp_flags);
         if (status < 0)
                 goto fail;
-        return 0;
+        goto done;
 fail:
         DEBUG (dev, "can't alloc requests\n");
+done:
+        spin_unlock(&dev->req_lock);
         return status;
 }
 
@@ -1800,21 +1816,21 @@ static void rx_fill (struct eth_dev *dev, gfp_t gfp_flags)
         unsigned long           flags;
 
         /* fill unused rxq slots with some skb */
-        spin_lock_irqsave (&dev->lock, flags);
+        spin_lock_irqsave(&dev->req_lock, flags);
         while (!list_empty (&dev->rx_reqs)) {
                 req = container_of (dev->rx_reqs.next,
                                 struct usb_request, list);
                 list_del_init (&req->list);
-                spin_unlock_irqrestore (&dev->lock, flags);
+                spin_unlock_irqrestore(&dev->req_lock, flags);
 
                 if (rx_submit (dev, req, gfp_flags) < 0) {
                         defer_kevent (dev, WORK_RX_MEMORY);
                         return;
                 }
 
-                spin_lock_irqsave (&dev->lock, flags);
+                spin_lock_irqsave(&dev->req_lock, flags);
         }
-        spin_unlock_irqrestore (&dev->lock, flags);
+        spin_unlock_irqrestore(&dev->req_lock, flags);
 }
 
 static void eth_work (void *_dev)
@@ -1848,9 +1864,9 @@ static void tx_complete (struct usb_ep *ep, struct usb_request *req)
         }
         dev->stats.tx_packets++;
 
-        spin_lock (&dev->lock);
+        spin_lock(&dev->req_lock);
         list_add (&req->list, &dev->tx_reqs);
-        spin_unlock (&dev->lock);
+        spin_unlock(&dev->req_lock);
         dev_kfree_skb_any (skb);
 
         atomic_dec (&dev->tx_qlen);
@@ -1896,12 +1912,12 @@ static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
                 /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
         }
 
-        spin_lock_irqsave (&dev->lock, flags);
+        spin_lock_irqsave(&dev->req_lock, flags);
         req = container_of (dev->tx_reqs.next, struct usb_request, list);
         list_del (&req->list);
         if (list_empty (&dev->tx_reqs))
                 netif_stop_queue (net);
-        spin_unlock_irqrestore (&dev->lock, flags);
+        spin_unlock_irqrestore(&dev->req_lock, flags);
 
         /* no buffer copies needed, unless the network stack did it
          * or the hardware can't use skb buffers.
@@ -1955,11 +1971,11 @@ static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
 drop:
                 dev->stats.tx_dropped++;
                 dev_kfree_skb_any (skb);
-                spin_lock_irqsave (&dev->lock, flags);
+                spin_lock_irqsave(&dev->req_lock, flags);
                 if (list_empty (&dev->tx_reqs))
                         netif_start_queue (net);
                 list_add (&req->list, &dev->tx_reqs);
-                spin_unlock_irqrestore (&dev->lock, flags);
+                spin_unlock_irqrestore(&dev->req_lock, flags);
         }
         return 0;
 }
@@ -2378,6 +2394,7 @@ autoconf_fail:
                 return status;
         dev = netdev_priv(net);
         spin_lock_init (&dev->lock);
+        spin_lock_init (&dev->req_lock);
         INIT_WORK (&dev->work, eth_work, dev);
         INIT_LIST_HEAD (&dev->tx_reqs);
         INIT_LIST_HEAD (&dev->rx_reqs);
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 66c3f61bc9d1..431e8f31f1a9 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -372,7 +372,7 @@ static void uhci_fixup_toggles(struct uhci_qh *qh, int skip_first)
                  * need to change any toggles in this URB */
                 td = list_entry(urbp->td_list.next, struct uhci_td, list);
                 if (toggle > 1 || uhci_toggle(td_token(td)) == toggle) {
-                        td = list_entry(urbp->td_list.next, struct uhci_td,
+                        td = list_entry(urbp->td_list.prev, struct uhci_td,
                                         list);
                         toggle = uhci_toggle(td_token(td)) ^ 1;
 
@@ -1348,7 +1348,7 @@ static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh,
                 }
 
                 uhci_giveback_urb(uhci, qh, urb, regs);
-                if (status < 0)
+                if (status < 0 && qh->type != USB_ENDPOINT_XFER_ISOC)
                         break;
         }
 
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index 8ea9c915fbf9..acb24c6219d9 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -1411,17 +1411,54 @@ void hid_init_reports(struct hid_device *hid)
                 warn("timeout initializing reports");
 }
 
+#define USB_VENDOR_ID_GTCO              0x078c
+#define USB_DEVICE_ID_GTCO_90           0x0090
+#define USB_DEVICE_ID_GTCO_100          0x0100
+#define USB_DEVICE_ID_GTCO_101          0x0101
+#define USB_DEVICE_ID_GTCO_103          0x0103
+#define USB_DEVICE_ID_GTCO_104          0x0104
+#define USB_DEVICE_ID_GTCO_105          0x0105
+#define USB_DEVICE_ID_GTCO_106          0x0106
+#define USB_DEVICE_ID_GTCO_107          0x0107
+#define USB_DEVICE_ID_GTCO_108          0x0108
+#define USB_DEVICE_ID_GTCO_200          0x0200
+#define USB_DEVICE_ID_GTCO_201          0x0201
+#define USB_DEVICE_ID_GTCO_202          0x0202
+#define USB_DEVICE_ID_GTCO_203          0x0203
+#define USB_DEVICE_ID_GTCO_204          0x0204
+#define USB_DEVICE_ID_GTCO_205          0x0205
+#define USB_DEVICE_ID_GTCO_206          0x0206
+#define USB_DEVICE_ID_GTCO_207          0x0207
+#define USB_DEVICE_ID_GTCO_300          0x0300
+#define USB_DEVICE_ID_GTCO_301          0x0301
+#define USB_DEVICE_ID_GTCO_302          0x0302
+#define USB_DEVICE_ID_GTCO_303          0x0303
+#define USB_DEVICE_ID_GTCO_304          0x0304
+#define USB_DEVICE_ID_GTCO_305          0x0305
+#define USB_DEVICE_ID_GTCO_306          0x0306
+#define USB_DEVICE_ID_GTCO_307          0x0307
+#define USB_DEVICE_ID_GTCO_308          0x0308
+#define USB_DEVICE_ID_GTCO_309          0x0309
+#define USB_DEVICE_ID_GTCO_400          0x0400
+#define USB_DEVICE_ID_GTCO_401          0x0401
+#define USB_DEVICE_ID_GTCO_402          0x0402
+#define USB_DEVICE_ID_GTCO_403          0x0403
+#define USB_DEVICE_ID_GTCO_404          0x0404
+#define USB_DEVICE_ID_GTCO_404          0x0405
+#define USB_DEVICE_ID_GTCO_500          0x0500
+#define USB_DEVICE_ID_GTCO_501          0x0501
+#define USB_DEVICE_ID_GTCO_502          0x0502
+#define USB_DEVICE_ID_GTCO_503          0x0503
+#define USB_DEVICE_ID_GTCO_504          0x0504
+#define USB_DEVICE_ID_GTCO_1000         0x1000
+#define USB_DEVICE_ID_GTCO_1001         0x1001
+#define USB_DEVICE_ID_GTCO_1002         0x1002
+#define USB_DEVICE_ID_GTCO_1003         0x1003
+#define USB_DEVICE_ID_GTCO_1004         0x1004
+#define USB_DEVICE_ID_GTCO_1005         0x1005
+#define USB_DEVICE_ID_GTCO_1006         0x1006
+
 #define USB_VENDOR_ID_WACOM             0x056a
-#define USB_DEVICE_ID_WACOM_PENPARTNER  0x0000
-#define USB_DEVICE_ID_WACOM_GRAPHIRE    0x0010
-#define USB_DEVICE_ID_WACOM_INTUOS      0x0020
-#define USB_DEVICE_ID_WACOM_PL          0x0030
-#define USB_DEVICE_ID_WACOM_INTUOS2     0x0040
-#define USB_DEVICE_ID_WACOM_VOLITO      0x0060
-#define USB_DEVICE_ID_WACOM_PTU         0x0003
-#define USB_DEVICE_ID_WACOM_INTUOS3     0x00B0
-#define USB_DEVICE_ID_WACOM_CINTIQ      0x003F
-#define USB_DEVICE_ID_WACOM_DTF         0x00C0
 
 #define USB_VENDOR_ID_ACECAD            0x0460
 #define USB_DEVICE_ID_ACECAD_FLAIR      0x0004
@@ -1588,6 +1625,51 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY, HID_QUIRK_IGNORE },
@@ -1617,49 +1699,6 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PENPARTNER, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 4, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS + 1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS + 2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS + 3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS + 4, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 4, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 5, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 7, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 8, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 9, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 4, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 5, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 7, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_VOLITO, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_VOLITO + 1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_VOLITO + 2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_VOLITO + 3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_VOLITO + 4, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 5, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 6, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PTU, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3 + 1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3 + 2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3 + 3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3 + 4, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3 + 5, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_CINTIQ, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_DTF, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_DTF + 3, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K, HID_QUIRK_IGNORE },
@@ -1778,6 +1817,10 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
         char *rdesc;
         int n, len, insize = 0;
 
+        /* Ignore all Wacom devices */
+        if (dev->descriptor.idVendor == USB_VENDOR_ID_WACOM)
+                return NULL;
+
         for (n = 0; hid_blacklist[n].idVendor; n++)
                 if ((hid_blacklist[n].idVendor == le16_to_cpu(dev->descriptor.idVendor)) &&
                         (hid_blacklist[n].idProduct == le16_to_cpu(dev->descriptor.idProduct)))
diff --git a/drivers/usb/net/pegasus.h b/drivers/usb/net/pegasus.h
index a54752ce1493..006438069b66 100644
--- a/drivers/usb/net/pegasus.h
+++ b/drivers/usb/net/pegasus.h
@@ -131,6 +131,7 @@ struct usb_eth_dev {
 #define VENDOR_COREGA           0x07aa
 #define VENDOR_DLINK            0x2001
 #define VENDOR_ELCON            0x0db7
+#define VENDOR_ELECOM           0x056e
 #define VENDOR_ELSA             0x05cc
 #define VENDOR_GIGABYTE         0x1044
 #define VENDOR_HAWKING          0x0e66
@@ -233,6 +234,8 @@ PEGASUS_DEV( "D-Link DSB-650", VENDOR_DLINK, 0xabc1,
                 DEFAULT_GPIO_RESET )
 PEGASUS_DEV( "GOLDPFEIL USB Adapter", VENDOR_ELCON, 0x0002,
                 DEFAULT_GPIO_RESET | PEGASUS_II | HAS_HOME_PNA )
+PEGASUS_DEV( "ELECOM USB Ethernet LD-USB20", VENDOR_ELECOM,  0x4010,
+                DEFAULT_GPIO_RESET  | PEGASUS_II )
 PEGASUS_DEV( "EasiDock Ethernet", VENDOR_MOBILITY, 0x0304,
                 DEFAULT_GPIO_RESET )
 PEGASUS_DEV( "Elsa Micolink USB2Ethernet", VENDOR_ELSA, 0x3000,
diff --git a/drivers/usb/net/rtl8150.c b/drivers/usb/net/rtl8150.c
index bd09232ce13c..a72685b96061 100644
--- a/drivers/usb/net/rtl8150.c
+++ b/drivers/usb/net/rtl8150.c
@@ -972,6 +972,7 @@ static void rtl8150_disconnect(struct usb_interface *intf)
         if (dev) {
                 set_bit(RTL8150_UNPLUG, &dev->flags);
                 tasklet_disable(&dev->tl);
+                tasklet_kill(&dev->tl);
                 unregister_netdev(dev->netdev);
                 unlink_all_urbs(dev);
                 free_all_urbs(dev);
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 4a803d69fa36..b130e170b4a8 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -241,16 +241,6 @@ UNUSUAL_DEV(  0x0482, 0x0103, 0x0100, 0x0100,
                 "Finecam S5",
                 US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_INQUIRY),
 
-/* Patch for Kyocera Finecam L3
- * Submitted by Michael Krauth <michael.krauth@web.de>
- * and Alessandro Fracchetti <al.fracchetti@tin.it>
- */
-UNUSUAL_DEV(  0x0482, 0x0105, 0x0100, 0x0100,
-                "Kyocera",
-                "Finecam L3",
-                US_SC_SCSI, US_PR_BULK, NULL,
-                US_FL_FIX_INQUIRY),
-
 /* Reported by Paul Stewart <stewart@wetlogic.net>
  * This entry is needed because the device reports Sub=ff */
 UNUSUAL_DEV(  0x04a4, 0x0004, 0x0001, 0x0001,
@@ -599,6 +589,13 @@ UNUSUAL_DEV(  0x054c, 0x0099, 0x0000, 0x9999,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
+/* floppy reports multiple luns */
+UNUSUAL_DEV(  0x055d, 0x2020, 0x0000, 0x0210,
+               "SAMSUNG",
+               "SFD-321U [FW 0C]",
+               US_SC_DEVICE, US_PR_DEVICE, NULL,
+               US_FL_SINGLE_LUN ),
+
                 
 UNUSUAL_DEV(  0x057b, 0x0000, 0x0000, 0x0299, 
                 "Y-E Data",
@@ -1257,6 +1254,13 @@ UNUSUAL_DEV(  0x0fce, 0xd008, 0x0000, 0x0000,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_NO_WP_DETECT ),
 
+/* Reported by Emmanuel Vasilakis <evas@forthnet.gr> */
+UNUSUAL_DEV(  0x0fce, 0xe031, 0x0000, 0x0000,
+                "Sony Ericsson",
+                "M600i",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY ),
+
 /* Reported by Kevin Cernekee <kpc-usbdev@gelato.uiuc.edu>
  * Tested on hardware version 1.10.
  * Entry is needed only for the initializer function override.
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 3e827e04a2aa..276a21530b95 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1801,10 +1801,14 @@ static struct backlight_properties aty128_bl_data = {
 static void aty128_bl_set_power(struct fb_info *info, int power)
 {
         mutex_lock(&info->bl_mutex);
-        up(&info->bl_dev->sem);
-        info->bl_dev->props->power = power;
-        __aty128_bl_update_status(info->bl_dev);
-        down(&info->bl_dev->sem);
+
+        if (info->bl_dev) {
+                down(&info->bl_dev->sem);
+                info->bl_dev->props->power = power;
+                __aty128_bl_update_status(info->bl_dev);
+                up(&info->bl_dev->sem);
+        }
+
         mutex_unlock(&info->bl_mutex);
 }
 
@@ -1828,7 +1832,7 @@ static void aty128_bl_init(struct aty128fb_par *par)
         bd = backlight_device_register(name, par, &aty128_bl_data);
         if (IS_ERR(bd)) {
                 info->bl_dev = NULL;
-                printk("aty128: Backlight registration failed\n");
+                printk(KERN_WARNING "aty128: Backlight registration failed\n");
                 goto error;
         }
 
@@ -1839,11 +1843,11 @@ static void aty128_bl_init(struct aty128fb_par *par)
                 219 * FB_BACKLIGHT_MAX / MAX_LEVEL);
         mutex_unlock(&info->bl_mutex);
 
-        up(&bd->sem);
+        down(&bd->sem);
         bd->props->brightness = aty128_bl_data.max_brightness;
         bd->props->power = FB_BLANK_UNBLANK;
         bd->props->update_status(bd);
-        down(&bd->sem);
+        up(&bd->sem);
 
 #ifdef CONFIG_PMAC_BACKLIGHT
         mutex_lock(&pmac_backlight_mutex);
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 053ff63365b7..19a71f045784 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -2200,10 +2200,14 @@ static struct backlight_properties aty_bl_data = {
 static void aty_bl_set_power(struct fb_info *info, int power)
 {
         mutex_lock(&info->bl_mutex);
-        up(&info->bl_dev->sem);
-        info->bl_dev->props->power = power;
-        __aty_bl_update_status(info->bl_dev);
-        down(&info->bl_dev->sem);
+
+        if (info->bl_dev) {
+                down(&info->bl_dev->sem);
+                info->bl_dev->props->power = power;
+                __aty_bl_update_status(info->bl_dev);
+                up(&info->bl_dev->sem);
+        }
+
         mutex_unlock(&info->bl_mutex);
 }
 
@@ -2223,7 +2227,7 @@ static void aty_bl_init(struct atyfb_par *par)
         bd = backlight_device_register(name, par, &aty_bl_data);
         if (IS_ERR(bd)) {
                 info->bl_dev = NULL;
-                printk("aty: Backlight registration failed\n");
+                printk(KERN_WARNING "aty: Backlight registration failed\n");
                 goto error;
         }
 
@@ -2234,11 +2238,11 @@ static void aty_bl_init(struct atyfb_par *par)
                 0xFF * FB_BACKLIGHT_MAX / MAX_LEVEL);
         mutex_unlock(&info->bl_mutex);
 
-        up(&bd->sem);
+        down(&bd->sem);
         bd->props->brightness = aty_bl_data.max_brightness;
         bd->props->power = FB_BLANK_UNBLANK;
         bd->props->update_status(bd);
-        down(&bd->sem);
+        up(&bd->sem);
 
 #ifdef CONFIG_PMAC_BACKLIGHT
         mutex_lock(&pmac_backlight_mutex);
diff --git a/drivers/video/aty/radeon_backlight.c b/drivers/video/aty/radeon_backlight.c
index 1755dddf1899..585eb7b9e636 100644
--- a/drivers/video/aty/radeon_backlight.c
+++ b/drivers/video/aty/radeon_backlight.c
@@ -195,11 +195,11 @@ void radeonfb_bl_init(struct radeonfb_info *rinfo)
                 217 * FB_BACKLIGHT_MAX / MAX_RADEON_LEVEL);
         mutex_unlock(&rinfo->info->bl_mutex);
 
-        up(&bd->sem);
+        down(&bd->sem);
         bd->props->brightness = radeon_bl_data.max_brightness;
         bd->props->power = FB_BLANK_UNBLANK;
         bd->props->update_status(bd);
-        down(&bd->sem);
+        up(&bd->sem);
 
 #ifdef CONFIG_PMAC_BACKLIGHT
         mutex_lock(&pmac_backlight_mutex);
diff --git a/drivers/video/nvidia/nv_backlight.c b/drivers/video/nvidia/nv_backlight.c
index b45f577094ac..5b75ae4e9457 100644
--- a/drivers/video/nvidia/nv_backlight.c
+++ b/drivers/video/nvidia/nv_backlight.c
@@ -113,10 +113,14 @@ static struct backlight_properties nvidia_bl_data = {
 void nvidia_bl_set_power(struct fb_info *info, int power)
 {
         mutex_lock(&info->bl_mutex);
-        up(&info->bl_dev->sem);
-        info->bl_dev->props->power = power;
-        __nvidia_bl_update_status(info->bl_dev);
-        down(&info->bl_dev->sem);
+
+        if (info->bl_dev) {
+                down(&info->bl_dev->sem);
+                info->bl_dev->props->power = power;
+                __nvidia_bl_update_status(info->bl_dev);
+                up(&info->bl_dev->sem);
+        }
+
         mutex_unlock(&info->bl_mutex);
 }
 
@@ -140,7 +144,7 @@ void nvidia_bl_init(struct nvidia_par *par)
         bd = backlight_device_register(name, par, &nvidia_bl_data);
         if (IS_ERR(bd)) {
                 info->bl_dev = NULL;
-                printk("nvidia: Backlight registration failed\n");
+                printk(KERN_WARNING "nvidia: Backlight registration failed\n");
                 goto error;
         }
 
@@ -151,11 +155,11 @@ void nvidia_bl_init(struct nvidia_par *par)
                 0x534 * FB_BACKLIGHT_MAX / MAX_LEVEL);
         mutex_unlock(&info->bl_mutex);
 
-        up(&bd->sem);
+        down(&bd->sem);
         bd->props->brightness = nvidia_bl_data.max_brightness;
         bd->props->power = FB_BLANK_UNBLANK;
         bd->props->update_status(bd);
-        down(&bd->sem);
+        up(&bd->sem);
 
 #ifdef CONFIG_PMAC_BACKLIGHT
         mutex_lock(&pmac_backlight_mutex);
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 76fc9d355eb7..8ddb47a56b07 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -355,10 +355,14 @@ static struct backlight_properties riva_bl_data = {
 static void riva_bl_set_power(struct fb_info *info, int power)
 {
         mutex_lock(&info->bl_mutex);
-        up(&info->bl_dev->sem);
-        info->bl_dev->props->power = power;
-        __riva_bl_update_status(info->bl_dev);
-        down(&info->bl_dev->sem);
+
+        if (info->bl_dev) {
+                down(&info->bl_dev->sem);
+                info->bl_dev->props->power = power;
+                __riva_bl_update_status(info->bl_dev);
+                up(&info->bl_dev->sem);
+        }
+
         mutex_unlock(&info->bl_mutex);
 }
 
@@ -382,7 +386,7 @@ static void riva_bl_init(struct riva_par *par)
         bd = backlight_device_register(name, par, &riva_bl_data);
         if (IS_ERR(bd)) {
                 info->bl_dev = NULL;
-                printk("riva: Backlight registration failed\n");
+                printk(KERN_WARNING "riva: Backlight registration failed\n");
                 goto error;
         }
 
@@ -393,11 +397,11 @@ static void riva_bl_init(struct riva_par *par)
                 0x534 * FB_BACKLIGHT_MAX / MAX_LEVEL);
         mutex_unlock(&info->bl_mutex);
 
-        up(&bd->sem);
+        down(&bd->sem);
         bd->props->brightness = riva_bl_data.max_brightness;
         bd->props->power = FB_BLANK_UNBLANK;
         bd->props->update_status(bd);
-        down(&bd->sem);
+        up(&bd->sem);
 
 #ifdef CONFIG_PMAC_BACKLIGHT
         mutex_lock(&pmac_backlight_mutex);