24 files changed, 417 insertions, 133 deletions

diff --git a/drivers/block/aoe/aoe.h b/drivers/block/aoe/aoe.h
index c237527b1aa5..5e41e6dd657b 100644
--- a/drivers/block/aoe/aoe.h
+++ b/drivers/block/aoe/aoe.h
@@ -18,6 +18,7 @@
 enum {
         AOECMD_ATA,
         AOECMD_CFG,
+        AOECMD_VEND_MIN = 0xf0,
 
         AOEFL_RSP = (1<<3),
         AOEFL_ERR = (1<<2),
diff --git a/drivers/block/aoe/aoenet.c b/drivers/block/aoe/aoenet.c
index 30de5b1c647e..c6099ba9a4b8 100644
--- a/drivers/block/aoe/aoenet.c
+++ b/drivers/block/aoe/aoenet.c
@@ -142,6 +142,8 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
                 aoecmd_cfg_rsp(skb);
                 break;
         default:
+                if (h->cmd >= AOECMD_VEND_MIN)
+                        break;  /* don't complain about vendor commands */
                 printk(KERN_INFO "aoe: unknown cmd %d\n", h->cmd);
         }
 exit:
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index cf29cc4e6ab7..83d8ed39433d 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -558,6 +558,8 @@ static void process_fd_request(void);
 static void recalibrate_floppy(void);
 static void floppy_shutdown(unsigned long);
 
+static int floppy_request_regions(int);
+static void floppy_release_regions(int);
 static int floppy_grab_irq_and_dma(void);
 static void floppy_release_irq_and_dma(void);
 
@@ -4274,8 +4276,7 @@ static int __init floppy_init(void)
                 FDCS->rawcmd = 2;
                 if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
                         /* free ioports reserved by floppy_grab_irq_and_dma() */
-                        release_region(FDCS->address + 2, 4);
-                        release_region(FDCS->address + 7, 1);
+                        floppy_release_regions(fdc);
                         FDCS->address = -1;
                         FDCS->version = FDC_NONE;
                         continue;
@@ -4284,8 +4285,7 @@ static int __init floppy_init(void)
                 FDCS->version = get_fdc_version();
                 if (FDCS->version == FDC_NONE) {
                         /* free ioports reserved by floppy_grab_irq_and_dma() */
-                        release_region(FDCS->address + 2, 4);
-                        release_region(FDCS->address + 7, 1);
+                        floppy_release_regions(fdc);
                         FDCS->address = -1;
                         continue;
                 }
@@ -4358,6 +4358,47 @@ out_put_disk:
 
 static DEFINE_SPINLOCK(floppy_usage_lock);
 
+static const struct io_region {
+        int offset;
+        int size;
+} io_regions[] = {
+        { 2, 1 },
+        /* address + 3 is sometimes reserved by pnp bios for motherboard */
+        { 4, 2 },
+        /* address + 6 is reserved, and may be taken by IDE.
+         * Unfortunately, Adaptec doesn't know this :-(, */
+        { 7, 1 },
+};
+
+static void floppy_release_allocated_regions(int fdc, const struct io_region *p)
+{
+        while (p != io_regions) {
+                p--;
+                release_region(FDCS->address + p->offset, p->size);
+        }
+}
+
+#define ARRAY_END(X) (&((X)[ARRAY_SIZE(X)]))
+
+static int floppy_request_regions(int fdc)
+{
+        const struct io_region *p;
+
+        for (p = io_regions; p < ARRAY_END(io_regions); p++) {
+                if (!request_region(FDCS->address + p->offset, p->size, "floppy")) {
+                        DPRINT("Floppy io-port 0x%04lx in use\n", FDCS->address + p->offset);
+                        floppy_release_allocated_regions(fdc, p);
+                        return -EBUSY;
+                }
+        }
+        return 0;
+}
+
+static void floppy_release_regions(int fdc)
+{
+        floppy_release_allocated_regions(fdc, ARRAY_END(io_regions));
+}
+
 static int floppy_grab_irq_and_dma(void)
 {
         unsigned long flags;
@@ -4399,18 +4440,8 @@ static int floppy_grab_irq_and_dma(void)
 
         for (fdc = 0; fdc < N_FDC; fdc++) {
                 if (FDCS->address != -1) {
-                        if (!request_region(FDCS->address + 2, 4, "floppy")) {
-                                DPRINT("Floppy io-port 0x%04lx in use\n",
-                                       FDCS->address + 2);
-                                goto cleanup1;
-                        }
-                        if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
-                                DPRINT("Floppy io-port 0x%04lx in use\n",
-                                       FDCS->address + 7);
-                                goto cleanup2;
-                        }
-                        /* address + 6 is reserved, and may be taken by IDE.
-                         * Unfortunately, Adaptec doesn't know this :-(, */
+                        if (floppy_request_regions(fdc))
+                                goto cleanup;
                 }
         }
         for (fdc = 0; fdc < N_FDC; fdc++) {
@@ -4432,15 +4463,11 @@ static int floppy_grab_irq_and_dma(void)
         fdc = 0;
         irqdma_allocated = 1;
         return 0;
-cleanup2:
-        release_region(FDCS->address + 2, 4);
-cleanup1:
+cleanup:
         fd_free_irq();
         fd_free_dma();
-        while (--fdc >= 0) {
-                release_region(FDCS->address + 2, 4);
-                release_region(FDCS->address + 7, 1);
-        }
+        while (--fdc >= 0)
+                floppy_release_regions(fdc);
         spin_lock_irqsave(&floppy_usage_lock, flags);
         usage_count--;
         spin_unlock_irqrestore(&floppy_usage_lock, flags);
@@ -4501,10 +4528,8 @@ static void floppy_release_irq_and_dma(void)
 #endif
         old_fdc = fdc;
         for (fdc = 0; fdc < N_FDC; fdc++)
-                if (FDCS->address != -1) {
-                        release_region(FDCS->address + 2, 4);
-                        release_region(FDCS->address + 7, 1);
-                }
+                if (FDCS->address != -1)
+                        floppy_release_regions(fdc);
         fdc = old_fdc;
 }
 
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index a58993011edb..280a9d263eb3 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -518,6 +518,7 @@ struct dma_chan *__dma_request_channel(dma_cap_mask_t *mask, dma_filter_fn fn, v
                                        dma_chan_name(chan), err);
                         else
                                 break;
+                        chan->private = NULL;
                         chan = NULL;
                 }
         }
@@ -536,6 +537,7 @@ void dma_release_channel(struct dma_chan *chan)
         WARN_ONCE(chan->client_count != 1,
                   "chan reference count %d != 1\n", chan->client_count);
         dma_chan_put(chan);
+        chan->private = NULL;
         mutex_unlock(&dma_list_mutex);
 }
 EXPORT_SYMBOL_GPL(dma_release_channel);
diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index 6b702cc46b3d..a97c07eef7ec 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -560,7 +560,7 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 unsigned long flags)
 {
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
-        struct dw_dma_slave     *dws = dwc->dws;
+        struct dw_dma_slave     *dws = chan->private;
         struct dw_desc          *prev;
         struct dw_desc          *first;
         u32                     ctllo;
@@ -790,7 +790,7 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
         cfghi = DWC_CFGH_FIFO_MODE;
         cfglo = 0;
 
-        dws = dwc->dws;
+        dws = chan->private;
         if (dws) {
                 /*
                  * We need controller-specific data to set up slave
@@ -866,7 +866,6 @@ static void dwc_free_chan_resources(struct dma_chan *chan)
         spin_lock_bh(&dwc->lock);
         list_splice_init(&dwc->free_list, &list);
         dwc->descs_allocated = 0;
-        dwc->dws = NULL;
 
         /* Disable interrupts */
         channel_clear_bit(dw, MASK.XFER, dwc->mask);
diff --git a/drivers/dma/dw_dmac_regs.h b/drivers/dma/dw_dmac_regs.h
index 00fdd187bb0c..b252b202c5cf 100644
--- a/drivers/dma/dw_dmac_regs.h
+++ b/drivers/dma/dw_dmac_regs.h
@@ -139,8 +139,6 @@ struct dw_dma_chan {
         struct list_head        queue;
         struct list_head        free_list;
 
-        struct dw_dma_slave     *dws;
-
         unsigned int            descs_allocated;
 };
 
diff --git a/drivers/firmware/memmap.c b/drivers/firmware/memmap.c
index 261b9aa3f248..05aa2d406ac6 100644
--- a/drivers/firmware/memmap.c
+++ b/drivers/firmware/memmap.c
@@ -1,7 +1,7 @@
 /*
  * linux/drivers/firmware/memmap.c
  *  Copyright (C) 2008 SUSE LINUX Products GmbH
- *  by Bernhard Walle <bwalle@suse.de>
+ *  by Bernhard Walle <bernhard.walle@gmx.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License v2.0 as published by
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 4be3acbaaf9a..3a22eb9be378 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -80,18 +80,17 @@ config DRM_I915
           XFree86 4.4 and above. If unsure, build this and i830 as modules and
           the X server will load the correct one.
 
-endchoice
-
 config DRM_I915_KMS
         bool "Enable modesetting on intel by default"
         depends on DRM_I915
         help
-        Choose this option if you want kernel modesetting enabled by default,
-        and you have a new enough userspace to support this. Running old
-        userspaces with this enabled will cause pain.  Note that this causes
-        the driver to bind to PCI devices, which precludes loading things
-        like intelfb.
+          Choose this option if you want kernel modesetting enabled by default,
+          and you have a new enough userspace to support this. Running old
+          userspaces with this enabled will cause pain.  Note that this causes
+          the driver to bind to PCI devices, which precludes loading things
+          like intelfb.
 
+endchoice
 
 config DRM_MGA
         tristate "Matrox g200/g400"
diff --git a/drivers/hwmon/hp_accel.c b/drivers/hwmon/hp_accel.c
index abf4dfc8ec22..29c83b5b9697 100644
--- a/drivers/hwmon/hp_accel.c
+++ b/drivers/hwmon/hp_accel.c
@@ -166,6 +166,18 @@ static struct axis_conversion lis3lv02d_axis_xy_swap_yz_inverted = {2, -1, -3};
         },                                              \
         .driver_data = &lis3lv02d_axis_##_axis          \
 }
+
+#define AXIS_DMI_MATCH2(_ident, _class1, _name1,        \
+                                _class2, _name2,        \
+                                _axis) {                \
+        .ident = _ident,                                \
+        .callback = lis3lv02d_dmi_matched,              \
+        .matches = {                                    \
+                DMI_MATCH(DMI_##_class1, _name1),       \
+                DMI_MATCH(DMI_##_class2, _name2),       \
+        },                                              \
+        .driver_data = &lis3lv02d_axis_##_axis          \
+}
 static struct dmi_system_id lis3lv02d_dmi_ids[] = {
         /* product names are truncated to match all kinds of a same model */
         AXIS_DMI_MATCH("NC64x0", "HP Compaq nc64", x_inverted),
@@ -179,6 +191,16 @@ static struct dmi_system_id lis3lv02d_dmi_ids[] = {
         AXIS_DMI_MATCH("NC673x", "HP Compaq 673", xy_rotated_left_usd),
         AXIS_DMI_MATCH("NC651xx", "HP Compaq 651", xy_rotated_right),
         AXIS_DMI_MATCH("NC671xx", "HP Compaq 671", xy_swap_yz_inverted),
+        /* Intel-based HP Pavilion dv5 */
+        AXIS_DMI_MATCH2("HPDV5_I",
+                        PRODUCT_NAME, "HP Pavilion dv5",
+                        BOARD_NAME, "3603",
+                        x_inverted),
+        /* AMD-based HP Pavilion dv5 */
+        AXIS_DMI_MATCH2("HPDV5_A",
+                        PRODUCT_NAME, "HP Pavilion dv5",
+                        BOARD_NAME, "3600",
+                        y_inverted),
         { NULL, }
 /* Laptop models without axis info (yet):
  * "NC6910" "HP Compaq 6910"
@@ -213,9 +235,49 @@ static struct delayed_led_classdev hpled_led = {
         .set_brightness = hpled_set,
 };
 
+static acpi_status
+lis3lv02d_get_resource(struct acpi_resource *resource, void *context)
+{
+        if (resource->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
+                struct acpi_resource_extended_irq *irq;
+                u32 *device_irq = context;
+
+                irq = &resource->data.extended_irq;
+                *device_irq = irq->interrupts[0];
+        }
+
+        return AE_OK;
+}
+
+static void lis3lv02d_enum_resources(struct acpi_device *device)
+{
+        acpi_status status;
+
+        status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
+                                        lis3lv02d_get_resource, &adev.irq);
+        if (ACPI_FAILURE(status))
+                printk(KERN_DEBUG DRIVER_NAME ": Error getting resources\n");
+}
+
+static s16 lis3lv02d_read_16(acpi_handle handle, int reg)
+{
+        u8 lo, hi;
+
+        adev.read(handle, reg - 1, &lo);
+        adev.read(handle, reg, &hi);
+        /* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */
+        return (s16)((hi << 8) | lo);
+}
+
+static s16 lis3lv02d_read_8(acpi_handle handle, int reg)
+{
+        s8 lo;
+        adev.read(handle, reg, &lo);
+        return lo;
+}
+
 static int lis3lv02d_add(struct acpi_device *device)
 {
-        u8 val;
         int ret;
 
         if (!device)
@@ -229,10 +291,22 @@ static int lis3lv02d_add(struct acpi_device *device)
         strcpy(acpi_device_class(device), ACPI_MDPS_CLASS);
         device->driver_data = &adev;
 
-        lis3lv02d_acpi_read(device->handle, WHO_AM_I, &val);
-        if ((val != LIS3LV02DL_ID) && (val != LIS302DL_ID)) {
+        lis3lv02d_acpi_read(device->handle, WHO_AM_I, &adev.whoami);
+        switch (adev.whoami) {
+        case LIS_DOUBLE_ID:
+                printk(KERN_INFO DRIVER_NAME ": 2-byte sensor found\n");
+                adev.read_data = lis3lv02d_read_16;
+                adev.mdps_max_val = 2048;
+                break;
+        case LIS_SINGLE_ID:
+                printk(KERN_INFO DRIVER_NAME ": 1-byte sensor found\n");
+                adev.read_data = lis3lv02d_read_8;
+                adev.mdps_max_val = 128;
+                break;
+        default:
                 printk(KERN_ERR DRIVER_NAME
-                                ": Accelerometer chip not LIS3LV02D{L,Q}\n");
+                        ": unknown sensor type 0x%X\n", adev.whoami);
+                return -EINVAL;
         }
 
         /* If possible use a "standard" axes order */
@@ -247,6 +321,9 @@ static int lis3lv02d_add(struct acpi_device *device)
         if (ret)
                 return ret;
 
+        /* obtain IRQ number of our device from ACPI */
+        lis3lv02d_enum_resources(adev.device);
+
         ret = lis3lv02d_init_device(&adev);
         if (ret) {
                 flush_work(&hpled_led.work);
diff --git a/drivers/hwmon/lis3lv02d.c b/drivers/hwmon/lis3lv02d.c
index 219d2d0d5a62..8bb2158f0453 100644
--- a/drivers/hwmon/lis3lv02d.c
+++ b/drivers/hwmon/lis3lv02d.c
@@ -3,7 +3,7 @@
  *
  *  Copyright (C) 2007-2008 Yan Burman
  *  Copyright (C) 2008 Eric Piel
- *  Copyright (C) 2008 Pavel Machek
+ *  Copyright (C) 2008-2009 Pavel Machek
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -35,6 +35,7 @@
 #include <linux/poll.h>
 #include <linux/freezer.h>
 #include <linux/uaccess.h>
+#include <linux/miscdevice.h>
 #include <acpi/acpi_drivers.h>
 #include <asm/atomic.h>
 #include "lis3lv02d.h"
@@ -52,24 +53,14 @@
  * joystick.
  */
 
-/* Maximum value our axis may get for the input device (signed 12 bits) */
-#define MDPS_MAX_VAL 2048
+struct acpi_lis3lv02d adev = {
+        .misc_wait   = __WAIT_QUEUE_HEAD_INITIALIZER(adev.misc_wait),
+};
 
-struct acpi_lis3lv02d adev;
 EXPORT_SYMBOL_GPL(adev);
 
 static int lis3lv02d_add_fs(struct acpi_device *device);
 
-static s16 lis3lv02d_read_16(acpi_handle handle, int reg)
-{
-        u8 lo, hi;
-
-        adev.read(handle, reg, &lo);
-        adev.read(handle, reg + 1, &hi);
-        /* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */
-        return (s16)((hi << 8) | lo);
-}
-
 /**
  * lis3lv02d_get_axis - For the given axis, give the value converted
  * @axis:      1,2,3 - can also be negative
@@ -98,9 +89,9 @@ static void lis3lv02d_get_xyz(acpi_handle handle, int *x, int *y, int *z)
 {
         int position[3];
 
-        position[0] = lis3lv02d_read_16(handle, OUTX_L);
-        position[1] = lis3lv02d_read_16(handle, OUTY_L);
-        position[2] = lis3lv02d_read_16(handle, OUTZ_L);
+        position[0] = adev.read_data(handle, OUTX);
+        position[1] = adev.read_data(handle, OUTY);
+        position[2] = adev.read_data(handle, OUTZ);
 
         *x = lis3lv02d_get_axis(adev.ac.x, position);
         *y = lis3lv02d_get_axis(adev.ac.y, position);
@@ -110,26 +101,13 @@ static void lis3lv02d_get_xyz(acpi_handle handle, int *x, int *y, int *z)
 void lis3lv02d_poweroff(acpi_handle handle)
 {
         adev.is_on = 0;
-        /* disable X,Y,Z axis and power down */
-        adev.write(handle, CTRL_REG1, 0x00);
 }
 EXPORT_SYMBOL_GPL(lis3lv02d_poweroff);
 
 void lis3lv02d_poweron(acpi_handle handle)
 {
-        u8 val;
-
         adev.is_on = 1;
         adev.init(handle);
-        adev.write(handle, FF_WU_CFG, 0);
-        /*
-         * BDU: LSB and MSB values are not updated until both have been read.
-         *      So the value read will always be correct.
-         * IEN: Interrupt for free-fall and DD, not for data-ready.
-         */
-        adev.read(handle, CTRL_REG2, &val);
-        val |= CTRL2_BDU | CTRL2_IEN;
-        adev.write(handle, CTRL_REG2, val);
 }
 EXPORT_SYMBOL_GPL(lis3lv02d_poweron);
 
@@ -162,6 +140,140 @@ static void lis3lv02d_decrease_use(struct acpi_lis3lv02d *dev)
         mutex_unlock(&dev->lock);
 }
 
+static irqreturn_t lis302dl_interrupt(int irq, void *dummy)
+{
+        /*
+         * Be careful: on some HP laptops the bios force DD when on battery and
+         * the lid is closed. This leads to interrupts as soon as a little move
+         * is done.
+         */
+        atomic_inc(&adev.count);
+
+        wake_up_interruptible(&adev.misc_wait);
+        kill_fasync(&adev.async_queue, SIGIO, POLL_IN);
+        return IRQ_HANDLED;
+}
+
+static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        if (test_and_set_bit(0, &adev.misc_opened))
+                return -EBUSY; /* already open */
+
+        atomic_set(&adev.count, 0);
+
+        /*
+         * The sensor can generate interrupts for free-fall and direction
+         * detection (distinguishable with FF_WU_SRC and DD_SRC) but to keep
+         * the things simple and _fast_ we activate it only for free-fall, so
+         * no need to read register (very slow with ACPI). For the same reason,
+         * we forbid shared interrupts.
+         *
+         * IRQF_TRIGGER_RISING seems pointless on HP laptops because the
+         * io-apic is not configurable (and generates a warning) but I keep it
+         * in case of support for other hardware.
+         */
+        ret = request_irq(adev.irq, lis302dl_interrupt, IRQF_TRIGGER_RISING,
+                          DRIVER_NAME, &adev);
+
+        if (ret) {
+                clear_bit(0, &adev.misc_opened);
+                printk(KERN_ERR DRIVER_NAME ": IRQ%d allocation failed\n", adev.irq);
+                return -EBUSY;
+        }
+        lis3lv02d_increase_use(&adev);
+        printk("lis3: registered interrupt %d\n", adev.irq);
+        return 0;
+}
+
+static int lis3lv02d_misc_release(struct inode *inode, struct file *file)
+{
+        fasync_helper(-1, file, 0, &adev.async_queue);
+        lis3lv02d_decrease_use(&adev);
+        free_irq(adev.irq, &adev);
+        clear_bit(0, &adev.misc_opened); /* release the device */
+        return 0;
+}
+
+static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
+                                size_t count, loff_t *pos)
+{
+        DECLARE_WAITQUEUE(wait, current);
+        u32 data;
+        unsigned char byte_data;
+        ssize_t retval = 1;
+
+        if (count < 1)
+                return -EINVAL;
+
+        add_wait_queue(&adev.misc_wait, &wait);
+        while (true) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                data = atomic_xchg(&adev.count, 0);
+                if (data)
+                        break;
+
+                if (file->f_flags & O_NONBLOCK) {
+                        retval = -EAGAIN;
+                        goto out;
+                }
+
+                if (signal_pending(current)) {
+                        retval = -ERESTARTSYS;
+                        goto out;
+                }
+
+                schedule();
+        }
+
+        if (data < 255)
+                byte_data = data;
+        else
+                byte_data = 255;
+
+        /* make sure we are not going into copy_to_user() with
+         * TASK_INTERRUPTIBLE state */
+        set_current_state(TASK_RUNNING);
+        if (copy_to_user(buf, &byte_data, sizeof(byte_data)))
+                retval = -EFAULT;
+
+out:
+        __set_current_state(TASK_RUNNING);
+        remove_wait_queue(&adev.misc_wait, &wait);
+
+        return retval;
+}
+
+static unsigned int lis3lv02d_misc_poll(struct file *file, poll_table *wait)
+{
+        poll_wait(file, &adev.misc_wait, wait);
+        if (atomic_read(&adev.count))
+                return POLLIN | POLLRDNORM;
+        return 0;
+}
+
+static int lis3lv02d_misc_fasync(int fd, struct file *file, int on)
+{
+        return fasync_helper(fd, file, on, &adev.async_queue);
+}
+
+static const struct file_operations lis3lv02d_misc_fops = {
+        .owner   = THIS_MODULE,
+        .llseek  = no_llseek,
+        .read    = lis3lv02d_misc_read,
+        .open    = lis3lv02d_misc_open,
+        .release = lis3lv02d_misc_release,
+        .poll    = lis3lv02d_misc_poll,
+        .fasync  = lis3lv02d_misc_fasync,
+};
+
+static struct miscdevice lis3lv02d_misc_device = {
+        .minor   = MISC_DYNAMIC_MINOR,
+        .name    = "freefall",
+        .fops    = &lis3lv02d_misc_fops,
+};
+
 /**
  * lis3lv02d_joystick_kthread - Kthread polling function
  * @data: unused - here to conform to threadfn prototype
@@ -203,7 +315,6 @@ static void lis3lv02d_joystick_close(struct input_dev *input)
         lis3lv02d_decrease_use(&adev);
 }
 
-
 static inline void lis3lv02d_calibrate_joystick(void)
 {
         lis3lv02d_get_xyz(adev.device->handle, &adev.xcalib, &adev.ycalib, &adev.zcalib);
@@ -231,9 +342,9 @@ int lis3lv02d_joystick_enable(void)
         adev.idev->close      = lis3lv02d_joystick_close;
 
         set_bit(EV_ABS, adev.idev->evbit);
-        input_set_abs_params(adev.idev, ABS_X, -MDPS_MAX_VAL, MDPS_MAX_VAL, 3, 3);
-        input_set_abs_params(adev.idev, ABS_Y, -MDPS_MAX_VAL, MDPS_MAX_VAL, 3, 3);
-        input_set_abs_params(adev.idev, ABS_Z, -MDPS_MAX_VAL, MDPS_MAX_VAL, 3, 3);
+        input_set_abs_params(adev.idev, ABS_X, -adev.mdps_max_val, adev.mdps_max_val, 3, 3);
+        input_set_abs_params(adev.idev, ABS_Y, -adev.mdps_max_val, adev.mdps_max_val, 3, 3);
+        input_set_abs_params(adev.idev, ABS_Z, -adev.mdps_max_val, adev.mdps_max_val, 3, 3);
 
         err = input_register_device(adev.idev);
         if (err) {
@@ -250,6 +361,7 @@ void lis3lv02d_joystick_disable(void)
         if (!adev.idev)
                 return;
 
+        misc_deregister(&lis3lv02d_misc_device);
         input_unregister_device(adev.idev);
         adev.idev = NULL;
 }
@@ -268,6 +380,19 @@ int lis3lv02d_init_device(struct acpi_lis3lv02d *dev)
         if (lis3lv02d_joystick_enable())
                 printk(KERN_ERR DRIVER_NAME ": joystick initialization failed\n");
 
+        printk("lis3_init_device: irq %d\n", dev->irq);
+
+        /* if we did not get an IRQ from ACPI - we have nothing more to do */
+        if (!dev->irq) {
+                printk(KERN_ERR DRIVER_NAME
+                        ": No IRQ in ACPI. Disabling /dev/freefall\n");
+                goto out;
+        }
+
+        printk("lis3: registering device\n");
+        if (misc_register(&lis3lv02d_misc_device))
+                printk(KERN_ERR DRIVER_NAME ": misc_register failed\n");
+out:
         lis3lv02d_decrease_use(dev);
         return 0;
 }
@@ -351,6 +476,6 @@ int lis3lv02d_remove_fs(void)
 EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs);
 
 MODULE_DESCRIPTION("ST LIS3LV02Dx three-axis digital accelerometer driver");
-MODULE_AUTHOR("Yan Burman and Eric Piel");
+MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/hwmon/lis3lv02d.h b/drivers/hwmon/lis3lv02d.h
index 223f1c0763bb..75972bf372ff 100644
--- a/drivers/hwmon/lis3lv02d.h
+++ b/drivers/hwmon/lis3lv02d.h
@@ -22,12 +22,15 @@
 /*
  * The actual chip is STMicroelectronics LIS3LV02DL or LIS3LV02DQ that seems to
  * be connected via SPI. There exists also several similar chips (such as LIS302DL or
- * LIS3L02DQ) but not in the HP laptops and they have slightly different registers.
+ * LIS3L02DQ) and they have slightly different registers, but we can provide a
+ * common interface for all of them.
  * They can also be connected via I²C.
  */
 
-#define LIS3LV02DL_ID   0x3A /* Also the LIS3LV02DQ */
-#define LIS302DL_ID     0x3B /* Also the LIS202DL! */
+/* 2-byte registers */
+#define LIS_DOUBLE_ID   0x3A /* LIS3LV02D[LQ] */
+/* 1-byte registers */
+#define LIS_SINGLE_ID   0x3B /* LIS[32]02DL and others */
 
 enum lis3lv02d_reg {
         WHO_AM_I        = 0x0F,
@@ -44,10 +47,13 @@ enum lis3lv02d_reg {
         STATUS_REG      = 0x27,
         OUTX_L          = 0x28,
         OUTX_H          = 0x29,
+        OUTX            = 0x29,
         OUTY_L          = 0x2A,
         OUTY_H          = 0x2B,
+        OUTY            = 0x2B,
         OUTZ_L          = 0x2C,
         OUTZ_H          = 0x2D,
+        OUTZ            = 0x2D,
         FF_WU_CFG       = 0x30,
         FF_WU_SRC       = 0x31,
         FF_WU_ACK       = 0x32,
@@ -159,6 +165,10 @@ struct acpi_lis3lv02d {
         acpi_status (*write) (acpi_handle handle, int reg, u8 val);
         acpi_status (*read) (acpi_handle handle, int reg, u8 *ret);
 
+        u8                      whoami;    /* 3Ah: 2-byte registries, 3Bh: 1-byte registries */
+        s16 (*read_data) (acpi_handle handle, int reg);
+        int                     mdps_max_val;
+
         struct input_dev        *idev;     /* input device */
         struct task_struct      *kthread;  /* kthread for input */
         struct mutex            lock;
@@ -170,6 +180,11 @@ struct acpi_lis3lv02d {
         unsigned char           is_on;     /* whether the device is on or off */
         unsigned char           usage;     /* usage counter */
         struct axis_conversion  ac;        /* hw -> logical axis */
+
+        u32                     irq;       /* IRQ number */
+        struct fasync_struct    *async_queue; /* queue for the misc device */
+        wait_queue_head_t       misc_wait; /* Wait queue for the misc device */
+        unsigned long           misc_opened; /* bit0: whether the device is open */
 };
 
 int lis3lv02d_init_device(struct acpi_lis3lv02d *dev);
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 45b1f430685f..513eb09a638f 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -584,7 +584,7 @@ static int mmc_blk_probe(struct mmc_card *card)
         if (err)
                 goto out;
 
-        string_get_size(get_capacity(md->disk) << 9, STRING_UNITS_2,
+        string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
                         cap_str, sizeof(cap_str));
         printk(KERN_INFO "%s: %s %s %s %s\n",
                 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index b92b172074ee..b9f1e84897cc 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -494,7 +494,7 @@ static int mmc_test_basic_read(struct mmc_test_card *test)
 
         sg_init_one(&sg, test->buffer, 512);
 
-        ret = mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 1);
+        ret = mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 0);
         if (ret)
                 return ret;
 
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 76bfe16c09b1..2b1196e6142c 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -1548,9 +1548,10 @@ static bool filter(struct dma_chan *chan, void *slave)
 {
         struct dw_dma_slave *dws = slave;
 
-        if (dws->dma_dev == chan->device->dev)
+        if (dws->dma_dev == chan->device->dev) {
+                chan->private = dws;
                 return true;
-        else
+        } else
                 return false;
 }
 #endif
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index db37490f67ec..a631c81dce12 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -55,6 +55,7 @@
 #define VS30                    (1 << 25)
 #define SDVS18                  (0x5 << 9)
 #define SDVS30                  (0x6 << 9)
+#define SDVS33                  (0x7 << 9)
 #define SDVSCLR                 0xFFFFF1FF
 #define SDVSDET                 0x00000400
 #define AUTOIDLE                0x1
@@ -375,6 +376,32 @@ static void mmc_omap_report_irq(struct mmc_omap_host *host, u32 status)
 }
 #endif  /* CONFIG_MMC_DEBUG */
 
+/*
+ * MMC controller internal state machines reset
+ *
+ * Used to reset command or data internal state machines, using respectively
+ *  SRC or SRD bit of SYSCTL register
+ * Can be called from interrupt context
+ */
+static inline void mmc_omap_reset_controller_fsm(struct mmc_omap_host *host,
+                unsigned long bit)
+{
+        unsigned long i = 0;
+        unsigned long limit = (loops_per_jiffy *
+                                msecs_to_jiffies(MMC_TIMEOUT_MS));
+
+        OMAP_HSMMC_WRITE(host->base, SYSCTL,
+                         OMAP_HSMMC_READ(host->base, SYSCTL) | bit);
+
+        while ((OMAP_HSMMC_READ(host->base, SYSCTL) & bit) &&
+                (i++ < limit))
+                cpu_relax();
+
+        if (OMAP_HSMMC_READ(host->base, SYSCTL) & bit)
+                dev_err(mmc_dev(host->mmc),
+                        "Timeout waiting on controller reset in %s\n",
+                        __func__);
+}
 
 /*
  * MMC controller IRQ handler
@@ -403,21 +430,17 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
                         (status & CMD_CRC)) {
                         if (host->cmd) {
                                 if (status & CMD_TIMEOUT) {
-                                        OMAP_HSMMC_WRITE(host->base, SYSCTL,
-                                                OMAP_HSMMC_READ(host->base,
-                                                                SYSCTL) | SRC);
-                                        while (OMAP_HSMMC_READ(host->base,
-                                                        SYSCTL) & SRC)
-                                                ;
-
+                                        mmc_omap_reset_controller_fsm(host, SRC);
                                         host->cmd->error = -ETIMEDOUT;
                                 } else {
                                         host->cmd->error = -EILSEQ;
                                 }
                                 end_cmd = 1;
                         }
-                        if (host->data)
+                        if (host->data) {
                                 mmc_dma_cleanup(host);
+                                mmc_omap_reset_controller_fsm(host, SRD);
+                        }
                 }
                 if ((status & DATA_TIMEOUT) ||
                         (status & DATA_CRC)) {
@@ -426,12 +449,7 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
                                         mmc_dma_cleanup(host);
                                 else
                                         host->data->error = -EILSEQ;
-                                OMAP_HSMMC_WRITE(host->base, SYSCTL,
-                                        OMAP_HSMMC_READ(host->base,
-                                                        SYSCTL) | SRD);
-                                while (OMAP_HSMMC_READ(host->base,
-                                                SYSCTL) & SRD)
-                                        ;
+                                mmc_omap_reset_controller_fsm(host, SRD);
                                 end_trans = 1;
                         }
                 }
@@ -456,13 +474,20 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
 }
 
 /*
- * Switch MMC operating voltage
+ * Switch MMC interface voltage ... only relevant for MMC1.
+ *
+ * MMC2 and MMC3 use fixed 1.8V levels, and maybe a transceiver.
+ * The MMC2 transceiver controls are used instead of DAT4..DAT7.
+ * Some chips, like eMMC ones, use internal transceivers.
  */
 static int omap_mmc_switch_opcond(struct mmc_omap_host *host, int vdd)
 {
         u32 reg_val = 0;
         int ret;
 
+        if (host->id != OMAP_MMC1_DEVID)
+                return 0;
+
         /* Disable the clocks */
         clk_disable(host->fclk);
         clk_disable(host->iclk);
@@ -485,19 +510,26 @@ static int omap_mmc_switch_opcond(struct mmc_omap_host *host, int vdd)
         OMAP_HSMMC_WRITE(host->base, HCTL,
                 OMAP_HSMMC_READ(host->base, HCTL) & SDVSCLR);
         reg_val = OMAP_HSMMC_READ(host->base, HCTL);
+
         /*
          * If a MMC dual voltage card is detected, the set_ios fn calls
          * this fn with VDD bit set for 1.8V. Upon card removal from the
          * slot, omap_mmc_set_ios sets the VDD back to 3V on MMC_POWER_OFF.
          *
-         * Only MMC1 supports 3.0V.  MMC2 will not function if SDVS30 is
-         * set in HCTL.
+         * Cope with a bit of slop in the range ... per data sheets:
+         *  - "1.8V" for vdds_mmc1/vdds_mmc1a can be up to 2.45V max,
+         *    but recommended values are 1.71V to 1.89V
+         *  - "3.0V" for vdds_mmc1/vdds_mmc1a can be up to 3.5V max,
+         *    but recommended values are 2.7V to 3.3V
+         *
+         * Board setup code shouldn't permit anything very out-of-range.
+         * TWL4030-family VMMC1 and VSIM regulators are fine (avoiding the
+         * middle range) but VSIM can't power DAT4..DAT7 at more than 3V.
          */
-        if (host->id == OMAP_MMC1_DEVID && (((1 << vdd) == MMC_VDD_32_33) ||
-                                ((1 << vdd) == MMC_VDD_33_34)))
-                reg_val |= SDVS30;
-        if ((1 << vdd) == MMC_VDD_165_195)
+        if ((1 << vdd) <= MMC_VDD_23_24)
                 reg_val |= SDVS18;
+        else
+                reg_val |= SDVS30;
 
         OMAP_HSMMC_WRITE(host->base, HCTL, reg_val);
 
@@ -517,16 +549,15 @@ static void mmc_omap_detect(struct work_struct *work)
 {
         struct mmc_omap_host *host = container_of(work, struct mmc_omap_host,
                                                 mmc_carddetect_work);
+        struct omap_mmc_slot_data *slot = &mmc_slot(host);
+
+        host->carddetect = slot->card_detect(slot->card_detect_irq);
 
         sysfs_notify(&host->mmc->class_dev.kobj, NULL, "cover_switch");
         if (host->carddetect) {
                 mmc_detect_change(host->mmc, (HZ * 200) / 1000);
         } else {
-                OMAP_HSMMC_WRITE(host->base, SYSCTL,
-                        OMAP_HSMMC_READ(host->base, SYSCTL) | SRD);
-                while (OMAP_HSMMC_READ(host->base, SYSCTL) & SRD)
-                        ;
-
+                mmc_omap_reset_controller_fsm(host, SRD);
                 mmc_detect_change(host->mmc, (HZ * 50) / 1000);
         }
 }
@@ -538,7 +569,6 @@ static irqreturn_t omap_mmc_cd_handler(int irq, void *dev_id)
 {
         struct mmc_omap_host *host = (struct mmc_omap_host *)dev_id;
 
-        host->carddetect = mmc_slot(host).card_detect(irq);
         schedule_work(&host->mmc_carddetect_work);
 
         return IRQ_HANDLED;
@@ -757,10 +787,14 @@ static void omap_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         case MMC_POWER_OFF:
                 mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);
                 /*
-                 * Reset bus voltage to 3V if it got set to 1.8V earlier.
+                 * Reset interface voltage to 3V if it's 1.8V now;
+                 * only relevant on MMC-1, the others always use 1.8V.
+                 *
                  * REVISIT: If we are able to detect cards after unplugging
                  * a 1.8V card, this code should not be needed.
                  */
+                if (host->id != OMAP_MMC1_DEVID)
+                        break;
                 if (!(OMAP_HSMMC_READ(host->base, HCTL) & SDVSDET)) {
                         int vdd = fls(host->mmc->ocr_avail) - 1;
                         if (omap_mmc_switch_opcond(host, vdd) != 0)
@@ -784,7 +818,9 @@ static void omap_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         }
 
         if (host->id == OMAP_MMC1_DEVID) {
-                /* Only MMC1 can operate at 3V/1.8V */
+                /* Only MMC1 can interface at 3V without some flavor
+                 * of external transceiver; but they all handle 1.8V.
+                 */
                 if ((OMAP_HSMMC_READ(host->base, HCTL) & SDVSDET) &&
                         (ios->vdd == DUAL_VOLT_OCR_BIT)) {
                                 /*
@@ -1137,7 +1173,9 @@ static int omap_mmc_suspend(struct platform_device *pdev, pm_message_t state)
                                                 " level suspend\n");
                         }
 
-                        if (!(OMAP_HSMMC_READ(host->base, HCTL) & SDVSDET)) {
+                        if (host->id == OMAP_MMC1_DEVID
+                                        && !(OMAP_HSMMC_READ(host->base, HCTL)
+                                                        & SDVSDET)) {
                                 OMAP_HSMMC_WRITE(host->base, HCTL,
                                         OMAP_HSMMC_READ(host->base, HCTL)
                                         & SDVSCLR);
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 35a98eec7414..f4a67c65d301 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -329,7 +329,7 @@ static void do_pio_write(struct s3cmci_host *host)
 
         to_ptr = host->base + host->sdidata;
 
-        while ((fifo = fifo_free(host))) {
+        while ((fifo = fifo_free(host)) > 3) {
                 if (!host->pio_bytes) {
                         res = get_data_buffer(host, &host->pio_bytes,
                                                         &host->pio_ptr);
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index f07255cb17ee..8cff5f5e7f86 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -144,8 +144,7 @@ static int jmicron_probe(struct sdhci_pci_chip *chip)
                           SDHCI_QUIRK_32BIT_DMA_SIZE |
                           SDHCI_QUIRK_32BIT_ADMA_SIZE |
                           SDHCI_QUIRK_RESET_AFTER_REQUEST |
-                          SDHCI_QUIRK_BROKEN_SMALL_PIO |
-                          SDHCI_QUIRK_FORCE_HIGHSPEED;
+                          SDHCI_QUIRK_BROKEN_SMALL_PIO;
         }
 
         /*
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 6b2d1f99af67..f52f3053ed92 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -1636,8 +1636,7 @@ int sdhci_add_host(struct sdhci_host *host)
         mmc->f_max = host->max_clk;
         mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
 
-        if ((caps & SDHCI_CAN_DO_HISPD) ||
-                (host->quirks & SDHCI_QUIRK_FORCE_HIGHSPEED))
+        if (caps & SDHCI_CAN_DO_HISPD)
                 mmc->caps |= MMC_CAP_SD_HIGHSPEED;
 
         mmc->ocr_avail = 0;
@@ -1723,7 +1722,9 @@ int sdhci_add_host(struct sdhci_host *host)
 #endif
 
 #ifdef SDHCI_USE_LEDS_CLASS
-        host->led.name = mmc_hostname(mmc);
+        snprintf(host->led_name, sizeof(host->led_name),
+                "%s::", mmc_hostname(mmc));
+        host->led.name = host->led_name;
         host->led.brightness = LED_OFF;
         host->led.default_trigger = mmc_hostname(mmc);
         host->led.brightness_set = sdhci_led_control;
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 3efba2363941..ebb83657e27a 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -208,8 +208,6 @@ struct sdhci_host {
 #define SDHCI_QUIRK_BROKEN_TIMEOUT_VAL                  (1<<12)
 /* Controller has an issue with buffer bits for small transfers */
 #define SDHCI_QUIRK_BROKEN_SMALL_PIO                    (1<<13)
-/* Controller supports high speed but doesn't have the caps bit set */
-#define SDHCI_QUIRK_FORCE_HIGHSPEED                     (1<<14)
 
         int                     irq;            /* Device IRQ */
         void __iomem *          ioaddr;         /* Mapped address */
@@ -222,6 +220,7 @@ struct sdhci_host {
 
 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
         struct led_classdev     led;            /* LED control */
+        char   led_name[32];
 #endif
 
         spinlock_t              lock;           /* Mutex */
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 94363115a42a..b3866ad50227 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -62,6 +62,7 @@ config DELL_LAPTOP
         depends on EXPERIMENTAL
         depends on BACKLIGHT_CLASS_DEVICE
         depends on RFKILL
+        depends on POWER_SUPPLY
         default n
         ---help---
         This driver adds support for rfkill and backlight control to Dell
@@ -301,6 +302,7 @@ config INTEL_MENLOW
 config EEEPC_LAPTOP
         tristate "Eee PC Hotkey Driver (EXPERIMENTAL)"
         depends on ACPI
+        depends on INPUT
         depends on EXPERIMENTAL
         select BACKLIGHT_CLASS_DEVICE
         select HWMON
diff --git a/drivers/serial/atmel_serial.c b/drivers/serial/atmel_serial.c
index 89362d733d62..8f58f7ff0dd7 100644
--- a/drivers/serial/atmel_serial.c
+++ b/drivers/serial/atmel_serial.c
@@ -877,6 +877,10 @@ static int atmel_startup(struct uart_port *port)
                 }
         }
 
+        /* Save current CSR for comparison in atmel_tasklet_func() */
+        atmel_port->irq_status_prev = UART_GET_CSR(port);
+        atmel_port->irq_status = atmel_port->irq_status_prev;
+
         /*
          * Finally, enable the serial port
          */
diff --git a/drivers/serial/jsm/jsm_driver.c b/drivers/serial/jsm/jsm_driver.c
index 92187e28608a..ac79cbe4c2cf 100644
--- a/drivers/serial/jsm/jsm_driver.c
+++ b/drivers/serial/jsm/jsm_driver.c
@@ -84,6 +84,8 @@ static int jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         brd->pci_dev = pdev;
         if (pdev->device == PCIE_DEVICE_ID_NEO_4_IBM)
                 brd->maxports = 4;
+        else if (pdev->device == PCI_DEVICE_ID_DIGI_NEO_8)
+                brd->maxports = 8;
         else
                 brd->maxports = 2;
 
@@ -212,6 +214,7 @@ static struct pci_device_id jsm_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45), 0, 0, 2 },
         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45PRI), 0, 0, 3 },
         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4_IBM), 0, 0, 4 },
+        { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_NEO_8), 0, 0, 5 },
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, jsm_pci_tbl);
diff --git a/drivers/spi/spi_gpio.c b/drivers/spi/spi_gpio.c
index 49698cabc30d..f5ed9721aabb 100644
--- a/drivers/spi/spi_gpio.c
+++ b/drivers/spi/spi_gpio.c
@@ -114,7 +114,7 @@ static inline void setmosi(const struct spi_device *spi, int is_on)
 
 static inline int getmiso(const struct spi_device *spi)
 {
-        return gpio_get_value(SPI_MISO_GPIO);
+        return !!gpio_get_value(SPI_MISO_GPIO);
 }
 
 #undef pdata
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index bf0af660df8a..fb19803060cf 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -1054,10 +1054,7 @@ config FB_RIVA_BACKLIGHT
 
 config FB_I810
         tristate "Intel 810/815 support (EXPERIMENTAL)"
-        depends on EXPERIMENTAL && PCI && X86_32
-        select AGP
-        select AGP_INTEL
-        select FB
+        depends on EXPERIMENTAL && FB && PCI && X86_32 && AGP_INTEL
         select FB_MODE_HELPERS
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
@@ -1120,10 +1117,7 @@ config FB_CARILLO_RANCH
 
 config FB_INTEL
         tristate "Intel 830M/845G/852GM/855GM/865G/915G/945G/945GM/965G/965GM support (EXPERIMENTAL)"
-        depends on EXPERIMENTAL && PCI && X86
-        select FB
-        select AGP
-        select AGP_INTEL
+        depends on EXPERIMENTAL && FB && PCI && X86 && AGP_INTEL
         select FB_MODE_HELPERS
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA