45 files changed, 1735 insertions, 942 deletions

diff --git a/drivers/char/hvc_iucv.c b/drivers/char/hvc_iucv.c
index 5ea7d7713fca..a53496828b76 100644
--- a/drivers/char/hvc_iucv.c
+++ b/drivers/char/hvc_iucv.c
@@ -1,26 +1,30 @@
 /*
- * hvc_iucv.c - z/VM IUCV back-end for the Hypervisor Console (HVC)
+ * hvc_iucv.c - z/VM IUCV hypervisor console (HVC) device driver
  *
- * This back-end for HVC provides terminal access via
+ * This HVC device driver provides terminal access using
  * z/VM IUCV communication paths.
  *
- * Copyright IBM Corp. 2008.
+ * Copyright IBM Corp. 2008
  *
  * Author(s):   Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
  */
 #define KMSG_COMPONENT          "hvc_iucv"
+#define pr_fmt(fmt)             KMSG_COMPONENT ": " fmt
 
 #include <linux/types.h>
 #include <asm/ebcdic.h>
+#include <linux/delay.h>
+#include <linux/init.h>
 #include <linux/mempool.h>
 #include <linux/module.h>
 #include <linux/tty.h>
+#include <linux/wait.h>
 #include <net/iucv/iucv.h>
 
 #include "hvc_console.h"
 
 
-/* HVC backend for z/VM IUCV */
+/* General device driver settings */
 #define HVC_IUCV_MAGIC          0xc9e4c3e5
 #define MAX_HVC_IUCV_LINES      HVC_ALLOC_TTY_ADAPTERS
 #define MEMPOOL_MIN_NR          (PAGE_SIZE / sizeof(struct iucv_tty_buffer)/4)
@@ -33,14 +37,14 @@
 #define MSG_TYPE_WINSIZE        0x08    /* Terminal window size update */
 #define MSG_TYPE_DATA           0x10    /* Terminal data */
 
-#define MSG_SIZE(s)             ((s) + offsetof(struct iucv_tty_msg, data))
 struct iucv_tty_msg {
         u8      version;                /* Message version */
         u8      type;                   /* Message type */
-#define MSG_MAX_DATALEN         (~(u16)0)
+#define MSG_MAX_DATALEN         ((u16)(~0))
         u16     datalen;                /* Payload length */
         u8      data[];                 /* Payload buffer */
 } __attribute__((packed));
+#define MSG_SIZE(s)             ((s) + offsetof(struct iucv_tty_msg, data))
 
 enum iucv_state_t {
         IUCV_DISCONN    = 0,
@@ -54,19 +58,26 @@ enum tty_state_t {
 };
 
 struct hvc_iucv_private {
-        struct hvc_struct       *hvc; /* HVC console struct reference */
+        struct hvc_struct       *hvc;           /* HVC struct reference */
         u8                      srv_name[8];    /* IUCV service name (ebcdic) */
+        unsigned char           is_console;     /* Linux console usage flag */
         enum iucv_state_t       iucv_state;     /* IUCV connection status */
         enum tty_state_t        tty_state;      /* TTY status */
         struct iucv_path        *path;          /* IUCV path pointer */
         spinlock_t              lock;           /* hvc_iucv_private lock */
+#define SNDBUF_SIZE             (PAGE_SIZE)     /* must be < MSG_MAX_DATALEN */
+        void                    *sndbuf;        /* send buffer            */
+        size_t                  sndbuf_len;     /* length of send buffer  */
+#define QUEUE_SNDBUF_DELAY      (HZ / 25)
+        struct delayed_work     sndbuf_work;    /* work: send iucv msg(s) */
+        wait_queue_head_t       sndbuf_waitq;   /* wait for send completion */
         struct list_head        tty_outqueue;   /* outgoing IUCV messages */
         struct list_head        tty_inqueue;    /* incoming IUCV messages */
 };
 
 struct iucv_tty_buffer {
         struct list_head        list;   /* list pointer */
-        struct iucv_message     msg;    /* store an incoming IUCV message */
+        struct iucv_message     msg;    /* store an IUCV message */
         size_t                  offset; /* data buffer offset */
         struct iucv_tty_msg     *mbuf;  /* buffer to store input/output data */
 };
@@ -78,11 +89,12 @@ static void hvc_iucv_msg_pending(struct iucv_path *, struct iucv_message *);
 static void hvc_iucv_msg_complete(struct iucv_path *, struct iucv_message *);
 
 
-/* Kernel module parameters */
-static unsigned long hvc_iucv_devices;
+/* Kernel module parameter: use one terminal device as default */
+static unsigned long hvc_iucv_devices = 1;
 
 /* Array of allocated hvc iucv tty lines... */
 static struct hvc_iucv_private *hvc_iucv_table[MAX_HVC_IUCV_LINES];
+#define IUCV_HVC_CON_IDX        (0)
 
 /* Kmem cache and mempool for iucv_tty_buffer elements */
 static struct kmem_cache *hvc_iucv_buffer_cache;
@@ -112,7 +124,7 @@ struct hvc_iucv_private *hvc_iucv_get_private(uint32_t num)
 }
 
 /**
- * alloc_tty_buffer() - Returns a new struct iucv_tty_buffer element.
+ * alloc_tty_buffer() - Return a new struct iucv_tty_buffer element.
  * @size:       Size of the internal buffer used to store data.
  * @flags:      Memory allocation flags passed to mempool.
  *
@@ -120,7 +132,6 @@ struct hvc_iucv_private *hvc_iucv_get_private(uint32_t num)
  * allocates an internal data buffer with the specified size @size.
  * Note: The total message size arises from the internal buffer size and the
  *       members of the iucv_tty_msg structure.
- *
  * The function returns NULL if memory allocation has failed.
  */
 static struct iucv_tty_buffer *alloc_tty_buffer(size_t size, gfp_t flags)
@@ -130,7 +141,7 @@ static struct iucv_tty_buffer *alloc_tty_buffer(size_t size, gfp_t flags)
         bufp = mempool_alloc(hvc_iucv_mempool, flags);
         if (!bufp)
                 return NULL;
-        memset(bufp, 0, sizeof(struct iucv_tty_buffer));
+        memset(bufp, 0, sizeof(*bufp));
 
         if (size > 0) {
                 bufp->msg.length = MSG_SIZE(size);
@@ -149,9 +160,6 @@ static struct iucv_tty_buffer *alloc_tty_buffer(size_t size, gfp_t flags)
 /**
  * destroy_tty_buffer() - destroy struct iucv_tty_buffer element.
  * @bufp:       Pointer to a struct iucv_tty_buffer element, SHALL NOT be NULL.
- *
- * The destroy_tty_buffer() function frees the internal data buffer and returns
- * the struct iucv_tty_buffer element back to the mempool for freeing.
  */
 static void destroy_tty_buffer(struct iucv_tty_buffer *bufp)
 {
@@ -161,11 +169,7 @@ static void destroy_tty_buffer(struct iucv_tty_buffer *bufp)
 
 /**
  * destroy_tty_buffer_list() - call destroy_tty_buffer() for each list element.
- * @list:       List head pointer to a list containing struct iucv_tty_buffer
- *              elements.
- *
- * Calls destroy_tty_buffer() for each struct iucv_tty_buffer element in the
- * list @list.
+ * @list:       List containing struct iucv_tty_buffer elements.
  */
 static void destroy_tty_buffer_list(struct list_head *list)
 {
@@ -178,24 +182,24 @@ static void destroy_tty_buffer_list(struct list_head *list)
 }
 
 /**
- * hvc_iucv_write() - Receive IUCV message write data to HVC console buffer.
- * @priv:               Pointer to hvc_iucv_private structure.
- * @buf:                HVC console buffer for writing received terminal data.
- * @count:              HVC console buffer size.
+ * hvc_iucv_write() - Receive IUCV message & write data to HVC buffer.
+ * @priv:               Pointer to struct hvc_iucv_private
+ * @buf:                HVC buffer for writing received terminal data.
+ * @count:              HVC buffer size.
  * @has_more_data:      Pointer to an int variable.
  *
  * The function picks up pending messages from the input queue and receives
  * the message data that is then written to the specified buffer @buf.
- * If the buffer size @count is less than the data message size, then the
+ * If the buffer size @count is less than the data message size, the
  * message is kept on the input queue and @has_more_data is set to 1.
- * If the message data has been entirely written, the message is removed from
+ * If all message data has been written, the message is removed from
  * the input queue.
  *
  * The function returns the number of bytes written to the terminal, zero if
  * there are no pending data messages available or if there is no established
  * IUCV path.
  * If the IUCV path has been severed, then -EPIPE is returned to cause a
- * hang up (that is issued by the HVC console layer).
+ * hang up (that is issued by the HVC layer).
  */
 static int hvc_iucv_write(struct hvc_iucv_private *priv,
                           char *buf, int count, int *has_more_data)
@@ -204,12 +208,12 @@ static int hvc_iucv_write(struct hvc_iucv_private *priv,
         int written;
         int rc;
 
-        /* Immediately return if there is no IUCV connection */
+        /* immediately return if there is no IUCV connection */
         if (priv->iucv_state == IUCV_DISCONN)
                 return 0;
 
-        /* If the IUCV path has been severed, return -EPIPE to inform the
-         * hvc console layer to hang up the tty device. */
+        /* if the IUCV path has been severed, return -EPIPE to inform the
+         * HVC layer to hang up the tty device. */
         if (priv->iucv_state == IUCV_SEVERED)
                 return -EPIPE;
 
@@ -217,7 +221,7 @@ static int hvc_iucv_write(struct hvc_iucv_private *priv,
         if (list_empty(&priv->tty_inqueue))
                 return 0;
 
-        /* receive a iucv message and flip data to the tty (ldisc) */
+        /* receive an iucv message and flip data to the tty (ldisc) */
         rb = list_first_entry(&priv->tty_inqueue, struct iucv_tty_buffer, list);
 
         written = 0;
@@ -260,7 +264,7 @@ static int hvc_iucv_write(struct hvc_iucv_private *priv,
         case MSG_TYPE_WINSIZE:
                 if (rb->mbuf->datalen != sizeof(struct winsize))
                         break;
-                hvc_resize(priv->hvc, *((struct winsize *)rb->mbuf->data));
+                hvc_resize(priv->hvc, *((struct winsize *) rb->mbuf->data));
                 break;
 
         case MSG_TYPE_ERROR:    /* ignored ... */
@@ -284,10 +288,9 @@ out_written:
  * @buf:        Pointer to a buffer to store data
  * @count:      Size of buffer available for writing
  *
- * The hvc_console thread calls this method to read characters from
- * the terminal backend. If an IUCV communication path has been established,
- * pending IUCV messages are received and data is copied into buffer @buf
- * up to @count bytes.
+ * The HVC thread calls this method to read characters from the back-end.
+ * If an IUCV communication path has been established, pending IUCV messages
+ * are received and data is copied into buffer @buf up to @count bytes.
  *
  * Locking:     The routine gets called under an irqsave() spinlock; and
  *              the routine locks the struct hvc_iucv_private->lock to call
@@ -318,66 +321,122 @@ static int hvc_iucv_get_chars(uint32_t vtermno, char *buf, int count)
 }
 
 /**
- * hvc_iucv_send() - Send an IUCV message containing terminal data.
+ * hvc_iucv_queue() - Buffer terminal data for sending.
  * @priv:       Pointer to struct hvc_iucv_private instance.
  * @buf:        Buffer containing data to send.
- * @size:       Size of buffer and amount of data to send.
+ * @count:      Size of buffer and amount of data to send.
+ *
+ * The function queues data for sending. To actually send the buffered data,
+ * a work queue function is scheduled (with QUEUE_SNDBUF_DELAY).
+ * The function returns the number of data bytes that has been buffered.
  *
- * If an IUCV communication path is established, the function copies the buffer
- * data to a newly allocated struct iucv_tty_buffer element, sends the data and
- * puts the element to the outqueue.
+ * If the device is not connected, data is ignored and the function returns
+ * @count.
+ * If the buffer is full, the function returns 0.
+ * If an existing IUCV communicaton path has been severed, -EPIPE is returned
+ * (that can be passed to HVC layer to cause a tty hangup).
+ */
+static int hvc_iucv_queue(struct hvc_iucv_private *priv, const char *buf,
+                          int count)
+{
+        size_t len;
+
+        if (priv->iucv_state == IUCV_DISCONN)
+                return count;                   /* ignore data */
+
+        if (priv->iucv_state == IUCV_SEVERED)
+                return -EPIPE;
+
+        len = min_t(size_t, count, SNDBUF_SIZE - priv->sndbuf_len);
+        if (!len)
+                return 0;
+
+        memcpy(priv->sndbuf + priv->sndbuf_len, buf, len);
+        priv->sndbuf_len += len;
+
+        if (priv->iucv_state == IUCV_CONNECTED)
+                schedule_delayed_work(&priv->sndbuf_work, QUEUE_SNDBUF_DELAY);
+
+        return len;
+}
+
+/**
+ * hvc_iucv_send() - Send an IUCV message containing terminal data.
+ * @priv:       Pointer to struct hvc_iucv_private instance.
  *
- * If there is no IUCV communication path established, the function returns 0.
- * If an existing IUCV communicaton path has been severed, the function returns
- * -EPIPE (can be passed to HVC layer to cause a tty hangup).
+ * If an IUCV communication path has been established, the buffered output data
+ * is sent via an IUCV message and the number of bytes sent is returned.
+ * Returns 0 if there is no established IUCV communication path or
+ * -EPIPE if an existing IUCV communicaton path has been severed.
  */
-static int hvc_iucv_send(struct hvc_iucv_private *priv, const char *buf,
-                         int count)
+static int hvc_iucv_send(struct hvc_iucv_private *priv)
 {
         struct iucv_tty_buffer *sb;
-        int rc;
-        u16 len;
+        int rc, len;
 
         if (priv->iucv_state == IUCV_SEVERED)
                 return -EPIPE;
 
         if (priv->iucv_state == IUCV_DISCONN)
-                return 0;
+                return -EIO;
 
-        len = min_t(u16, MSG_MAX_DATALEN, count);
+        if (!priv->sndbuf_len)
+                return 0;
 
         /* allocate internal buffer to store msg data and also compute total
          * message length */
-        sb = alloc_tty_buffer(len, GFP_ATOMIC);
+        sb = alloc_tty_buffer(priv->sndbuf_len, GFP_ATOMIC);
         if (!sb)
                 return -ENOMEM;
 
-        sb->mbuf->datalen = len;
-        memcpy(sb->mbuf->data, buf, len);
+        memcpy(sb->mbuf->data, priv->sndbuf, priv->sndbuf_len);
+        sb->mbuf->datalen = (u16) priv->sndbuf_len;
+        sb->msg.length = MSG_SIZE(sb->mbuf->datalen);
 
         list_add_tail(&sb->list, &priv->tty_outqueue);
 
         rc = __iucv_message_send(priv->path, &sb->msg, 0, 0,
                                  (void *) sb->mbuf, sb->msg.length);
         if (rc) {
+                /* drop the message here; however we might want to handle
+                 * 0x03 (msg limit reached) by trying again... */
                 list_del(&sb->list);
                 destroy_tty_buffer(sb);
-                len = 0;
         }
+        len = priv->sndbuf_len;
+        priv->sndbuf_len = 0;
 
         return len;
 }
 
 /**
+ * hvc_iucv_sndbuf_work() - Send buffered data over IUCV
+ * @work:       Work structure.
+ *
+ * This work queue function sends buffered output data over IUCV and,
+ * if not all buffered data could be sent, reschedules itself.
+ */
+static void hvc_iucv_sndbuf_work(struct work_struct *work)
+{
+        struct hvc_iucv_private *priv;
+
+        priv = container_of(work, struct hvc_iucv_private, sndbuf_work.work);
+        if (!priv)
+                return;
+
+        spin_lock_bh(&priv->lock);
+        hvc_iucv_send(priv);
+        spin_unlock_bh(&priv->lock);
+}
+
+/**
  * hvc_iucv_put_chars() - HVC put_chars operation.
  * @vtermno:    HVC virtual terminal number.
  * @buf:        Pointer to an buffer to read data from
  * @count:      Size of buffer available for reading
  *
- * The hvc_console thread calls this method to write characters from
- * to the terminal backend.
- * The function calls hvc_iucv_send() under the lock of the
- * struct hvc_iucv_private instance that corresponds to the tty @vtermno.
+ * The HVC thread calls this method to write characters to the back-end.
+ * The function calls hvc_iucv_queue() to queue terminal data for sending.
  *
  * Locking:     The method gets called under an irqsave() spinlock; and
  *              locks struct hvc_iucv_private->lock.
@@ -385,7 +444,7 @@ static int hvc_iucv_send(struct hvc_iucv_private *priv, const char *buf,
 static int hvc_iucv_put_chars(uint32_t vtermno, const char *buf, int count)
 {
         struct hvc_iucv_private *priv = hvc_iucv_get_private(vtermno);
-        int sent;
+        int queued;
 
         if (count <= 0)
                 return 0;
@@ -394,10 +453,10 @@ static int hvc_iucv_put_chars(uint32_t vtermno, const char *buf, int count)
                 return -ENODEV;
 
         spin_lock(&priv->lock);
-        sent = hvc_iucv_send(priv, buf, count);
+        queued = hvc_iucv_queue(priv, buf, count);
         spin_unlock(&priv->lock);
 
-        return sent;
+        return queued;
 }
 
 /**
@@ -406,7 +465,7 @@ static int hvc_iucv_put_chars(uint32_t vtermno, const char *buf, int count)
  * @id: Additional data (originally passed to hvc_alloc): the index of an struct
  *      hvc_iucv_private instance.
  *
- * The function sets the tty state to TTY_OPEN for the struct hvc_iucv_private
+ * The function sets the tty state to TTY_OPENED for the struct hvc_iucv_private
  * instance that is derived from @id. Always returns 0.
  *
  * Locking:     struct hvc_iucv_private->lock, spin_lock_bh
@@ -427,12 +486,8 @@ static int hvc_iucv_notifier_add(struct hvc_struct *hp, int id)
 }
 
 /**
- * hvc_iucv_cleanup() - Clean up function if the tty portion is finally closed.
+ * hvc_iucv_cleanup() - Clean up and reset a z/VM IUCV HVC instance.
  * @priv:       Pointer to the struct hvc_iucv_private instance.
- *
- * The functions severs the established IUCV communication path (if any), and
- * destroy struct iucv_tty_buffer elements from the in- and outqueue. Finally,
- * the functions resets the states to TTY_CLOSED and IUCV_DISCONN.
  */
 static void hvc_iucv_cleanup(struct hvc_iucv_private *priv)
 {
@@ -441,25 +496,62 @@ static void hvc_iucv_cleanup(struct hvc_iucv_private *priv)
 
         priv->tty_state = TTY_CLOSED;
         priv->iucv_state = IUCV_DISCONN;
+
+        priv->sndbuf_len = 0;
 }
 
 /**
- * hvc_iucv_notifier_hangup() - HVC notifier for tty hangups.
- * @hp: Pointer to the HVC device (struct hvc_struct)
- * @id: Additional data (originally passed to hvc_alloc): the index of an struct
- *      hvc_iucv_private instance.
+ * tty_outqueue_empty() - Test if the tty outq is empty
+ * @priv:       Pointer to struct hvc_iucv_private instance.
+ */
+static inline int tty_outqueue_empty(struct hvc_iucv_private *priv)
+{
+        int rc;
+
+        spin_lock_bh(&priv->lock);
+        rc = list_empty(&priv->tty_outqueue);
+        spin_unlock_bh(&priv->lock);
+
+        return rc;
+}
+
+/**
+ * flush_sndbuf_sync() - Flush send buffer and wait for completion
+ * @priv:       Pointer to struct hvc_iucv_private instance.
  *
- * This routine notifies the HVC backend that a tty hangup (carrier loss,
- * virtual or otherwise) has occured.
+ * The routine cancels a pending sndbuf work, calls hvc_iucv_send()
+ * to flush any buffered terminal output data and waits for completion.
+ */
+static void flush_sndbuf_sync(struct hvc_iucv_private *priv)
+{
+        int sync_wait;
+
+        cancel_delayed_work_sync(&priv->sndbuf_work);
+
+        spin_lock_bh(&priv->lock);
+        hvc_iucv_send(priv);            /* force sending buffered data */
+        sync_wait = !list_empty(&priv->tty_outqueue); /* anything queued ? */
+        spin_unlock_bh(&priv->lock);
+
+        if (sync_wait)
+                wait_event_timeout(priv->sndbuf_waitq,
+                                   tty_outqueue_empty(priv), HZ);
+}
+
+/**
+ * hvc_iucv_notifier_hangup() - HVC notifier for TTY hangups.
+ * @hp:         Pointer to the HVC device (struct hvc_struct)
+ * @id:         Additional data (originally passed to hvc_alloc):
+ *              the index of an struct hvc_iucv_private instance.
  *
- * The HVC backend for z/VM IUCV ignores virtual hangups (vhangup()), to keep
- * an existing IUCV communication path established.
+ * This routine notifies the HVC back-end that a tty hangup (carrier loss,
+ * virtual or otherwise) has occured.
+ * The z/VM IUCV HVC device driver ignores virtual hangups (vhangup())
+ * to keep an existing IUCV communication path established.
  * (Background: vhangup() is called from user space (by getty or login) to
  *              disable writing to the tty by other applications).
- *
- * If the tty has been opened (e.g. getty) and an established IUCV path has been
- * severed (we caused the tty hangup in that case), then the functions invokes
- * hvc_iucv_cleanup() to clean up.
+ * If the tty has been opened and an established IUCV path has been severed
+ * (we caused the tty hangup), the function calls hvc_iucv_cleanup().
  *
  * Locking:     struct hvc_iucv_private->lock
  */
@@ -471,12 +563,12 @@ static void hvc_iucv_notifier_hangup(struct hvc_struct *hp, int id)
         if (!priv)
                 return;
 
+        flush_sndbuf_sync(priv);
+
         spin_lock_bh(&priv->lock);
         /* NOTE: If the hangup was scheduled by ourself (from the iucv
-         *       path_servered callback [IUCV_SEVERED]), then we have to
-         *       finally clean up the tty backend structure and set state to
-         *       TTY_CLOSED.
-         *
+         *       path_servered callback [IUCV_SEVERED]), we have to clean up
+         *       our structure and to set state to TTY_CLOSED.
          *       If the tty was hung up otherwise (e.g. vhangup()), then we
          *       ignore this hangup and keep an established IUCV path open...
          *       (...the reason is that we are not able to connect back to the
@@ -494,10 +586,9 @@ static void hvc_iucv_notifier_hangup(struct hvc_struct *hp, int id)
  * @id:         Additional data (originally passed to hvc_alloc):
  *              the index of an struct hvc_iucv_private instance.
  *
- * This routine notifies the HVC backend that the last tty device file
- * descriptor has been closed.
- * The function calls hvc_iucv_cleanup() to clean up the struct hvc_iucv_private
- * instance.
+ * This routine notifies the HVC back-end that the last tty device fd has been
+ * closed.  The function calls hvc_iucv_cleanup() to clean up the struct
+ * hvc_iucv_private instance.
  *
  * Locking:     struct hvc_iucv_private->lock
  */
@@ -510,6 +601,8 @@ static void hvc_iucv_notifier_del(struct hvc_struct *hp, int id)
         if (!priv)
                 return;
 
+        flush_sndbuf_sync(priv);
+
         spin_lock_bh(&priv->lock);
         path = priv->path;              /* save reference to IUCV path */
         priv->path = NULL;
@@ -527,20 +620,18 @@ static void hvc_iucv_notifier_del(struct hvc_struct *hp, int id)
 /**
  * hvc_iucv_path_pending() - IUCV handler to process a connection request.
  * @path:       Pending path (struct iucv_path)
- * @ipvmid:     Originator z/VM system identifier
+ * @ipvmid:     z/VM system identifier of originator
  * @ipuser:     User specified data for this path
  *              (AF_IUCV: port/service name and originator port)
  *
- * The function uses the @ipuser data to check to determine if the pending
- * path belongs to a terminal managed by this HVC backend.
- * If the check is successful, then an additional check is done to ensure
- * that a terminal cannot be accessed multiple times (only one connection
- * to a terminal is allowed). In that particular case, the pending path is
- * severed. If it is the first connection, the pending path is accepted and
- * associated to the struct hvc_iucv_private. The iucv state is updated to
- * reflect that a communication path has been established.
+ * The function uses the @ipuser data to determine if the pending path belongs
+ * to a terminal managed by this device driver.
+ * If the path belongs to this driver, ensure that the terminal is not accessed
+ * multiple times (only one connection to a terminal is allowed).
+ * If the terminal is not yet connected, the pending path is accepted and is
+ * associated to the appropriate struct hvc_iucv_private instance.
  *
- * Returns 0 if the path belongs to a terminal managed by the this HVC backend;
+ * Returns 0 if @path belongs to a terminal managed by the this device driver;
  * otherwise returns -ENODEV in order to dispatch this path to other handlers.
  *
  * Locking:     struct hvc_iucv_private->lock
@@ -559,7 +650,6 @@ static	int hvc_iucv_path_pending(struct iucv_path *path,
                         priv = hvc_iucv_table[i];
                         break;
                 }
-
         if (!priv)
                 return -ENODEV;
 
@@ -588,6 +678,9 @@ static	int hvc_iucv_path_pending(struct iucv_path *path,
         priv->path = path;
         priv->iucv_state = IUCV_CONNECTED;
 
+        /* flush buffered output data... */
+        schedule_delayed_work(&priv->sndbuf_work, 5);
+
 out_path_handled:
         spin_unlock(&priv->lock);
         return 0;
@@ -603,8 +696,7 @@ out_path_handled:
  * sets the iucv state to IUCV_SEVERED for the associated struct
  * hvc_iucv_private instance. Later, the IUCV_SEVERED state triggers a tty
  * hangup (hvc_iucv_get_chars() / hvc_iucv_write()).
- *
- * If tty portion of the HVC is closed then clean up the outqueue in addition.
+ * If tty portion of the HVC is closed, clean up the outqueue.
  *
  * Locking:     struct hvc_iucv_private->lock
  */
@@ -615,15 +707,25 @@ static void hvc_iucv_path_severed(struct iucv_path *path, u8 ipuser[16])
         spin_lock(&priv->lock);
         priv->iucv_state = IUCV_SEVERED;
 
-        /* NOTE: If the tty has not yet been opened by a getty program
-         *       (e.g. to see console messages), then cleanup the
-         *       hvc_iucv_private structure to allow re-connects.
+        /* If the tty has not yet been opened, clean up the hvc_iucv_private
+         * structure to allow re-connects.
+         * This is also done for our console device because console hangups
+         * are handled specially and no notifier is called by HVC.
+         * The tty session is active (TTY_OPEN) and ready for re-connects...
          *
-         *       If the tty has been opened, the get_chars() callback returns
-         *       -EPIPE to signal the hvc console layer to hang up the tty. */
+         * If it has been opened, let get_chars() return -EPIPE to signal the
+         * HVC layer to hang up the tty.
+         * If so, we need to wake up the HVC thread to call get_chars()...
+         */
         priv->path = NULL;
         if (priv->tty_state == TTY_CLOSED)
                 hvc_iucv_cleanup(priv);
+        else
+                if (priv->is_console) {
+                        hvc_iucv_cleanup(priv);
+                        priv->tty_state = TTY_OPENED;
+                } else
+                        hvc_kick();
         spin_unlock(&priv->lock);
 
         /* finally sever path (outside of priv->lock due to lock ordering) */
@@ -636,9 +738,9 @@ static void hvc_iucv_path_severed(struct iucv_path *path, u8 ipuser[16])
  * @path:       Pending path (struct iucv_path)
  * @msg:        Pointer to the IUCV message
  *
- * The function stores an incoming message on the input queue for later
+ * The function puts an incoming message on the input queue for later
  * processing (by hvc_iucv_get_chars() / hvc_iucv_write()).
- * However, if the tty has not yet been opened, the message is rejected.
+ * If the tty has not yet been opened, the message is rejected.
  *
  * Locking:     struct hvc_iucv_private->lock
  */
@@ -648,6 +750,12 @@ static void hvc_iucv_msg_pending(struct iucv_path *path,
         struct hvc_iucv_private *priv = path->private;
         struct iucv_tty_buffer *rb;
 
+        /* reject messages that exceed max size of iucv_tty_msg->datalen */
+        if (msg->length > MSG_SIZE(MSG_MAX_DATALEN)) {
+                iucv_message_reject(path, msg);
+                return;
+        }
+
         spin_lock(&priv->lock);
 
         /* reject messages if tty has not yet been opened */
@@ -656,7 +764,7 @@ static void hvc_iucv_msg_pending(struct iucv_path *path,
                 goto unlock_return;
         }
 
-        /* allocate buffer an empty buffer element */
+        /* allocate tty buffer to save iucv msg only */
         rb = alloc_tty_buffer(0, GFP_ATOMIC);
         if (!rb) {
                 iucv_message_reject(path, msg);
@@ -666,7 +774,7 @@ static void hvc_iucv_msg_pending(struct iucv_path *path,
 
         list_add_tail(&rb->list, &priv->tty_inqueue);
 
-        hvc_kick();     /* wakup hvc console thread */
+        hvc_kick();     /* wake up hvc thread */
 
 unlock_return:
         spin_unlock(&priv->lock);
@@ -677,10 +785,10 @@ unlock_return:
  * @path:       Pending path (struct iucv_path)
  * @msg:        Pointer to the IUCV message
  *
- * The function is called upon completion of message delivery and the
- * message is removed from the outqueue. Additional delivery information
- * can be found in msg->audit: rejected messages (0x040000 (IPADRJCT)) and
- * purged messages (0x010000 (IPADPGNR)).
+ * The function is called upon completion of message delivery to remove the
+ * message from the outqueue. Additional delivery information can be found
+ * msg->audit: rejected messages (0x040000 (IPADRJCT)), and
+ *             purged messages   (0x010000 (IPADPGNR)).
  *
  * Locking:     struct hvc_iucv_private->lock
  */
@@ -697,6 +805,7 @@ static void hvc_iucv_msg_complete(struct iucv_path *path,
                         list_move(&ent->list, &list_remove);
                         break;
                 }
+        wake_up(&priv->sndbuf_waitq);
         spin_unlock(&priv->lock);
         destroy_tty_buffer_list(&list_remove);
 }
@@ -713,13 +822,14 @@ static struct hv_ops hvc_iucv_ops = {
 
 /**
  * hvc_iucv_alloc() - Allocates a new struct hvc_iucv_private instance
- * @id: hvc_iucv_table index
+ * @id:                 hvc_iucv_table index
+ * @is_console:         Flag if the instance is used as Linux console
  *
- * This function allocates a new hvc_iucv_private struct and put the
- * instance into hvc_iucv_table at index @id.
+ * This function allocates a new hvc_iucv_private structure and stores
+ * the instance in hvc_iucv_table at index @id.
  * Returns 0 on success; otherwise non-zero.
  */
-static int __init hvc_iucv_alloc(int id)
+static int __init hvc_iucv_alloc(int id, unsigned int is_console)
 {
         struct hvc_iucv_private *priv;
         char name[9];
@@ -732,18 +842,33 @@ static int __init hvc_iucv_alloc(int id)
         spin_lock_init(&priv->lock);
         INIT_LIST_HEAD(&priv->tty_outqueue);
         INIT_LIST_HEAD(&priv->tty_inqueue);
+        INIT_DELAYED_WORK(&priv->sndbuf_work, hvc_iucv_sndbuf_work);
+        init_waitqueue_head(&priv->sndbuf_waitq);
+
+        priv->sndbuf = (void *) get_zeroed_page(GFP_KERNEL);
+        if (!priv->sndbuf) {
+                kfree(priv);
+                return -ENOMEM;
+        }
+
+        /* set console flag */
+        priv->is_console = is_console;
 
-        /* Finally allocate hvc */
-        priv->hvc = hvc_alloc(HVC_IUCV_MAGIC + id,
-                              HVC_IUCV_MAGIC + id, &hvc_iucv_ops, PAGE_SIZE);
+        /* finally allocate hvc */
+        priv->hvc = hvc_alloc(HVC_IUCV_MAGIC + id, /*             PAGE_SIZE */
+                              HVC_IUCV_MAGIC + id, &hvc_iucv_ops, 256);
         if (IS_ERR(priv->hvc)) {
                 rc = PTR_ERR(priv->hvc);
+                free_page((unsigned long) priv->sndbuf);
                 kfree(priv);
                 return rc;
         }
 
+        /* notify HVC thread instead of using polling */
+        priv->hvc->irq_requested = 1;
+
         /* setup iucv related information */
-        snprintf(name, 9, "ihvc%-4d", id);
+        snprintf(name, 9, "lnxhvc%-2d", id);
         memcpy(priv->srv_name, name, 8);
         ASCEBC(priv->srv_name, 8);
 
@@ -752,15 +877,16 @@ static int __init hvc_iucv_alloc(int id)
 }
 
 /**
- * hvc_iucv_init() - Initialization of HVC backend for z/VM IUCV
+ * hvc_iucv_init() - z/VM IUCV HVC device driver initialization
  */
 static int __init hvc_iucv_init(void)
 {
-        int rc, i;
+        int rc;
+        unsigned int i;
 
         if (!MACHINE_IS_VM) {
-                pr_warning("The z/VM IUCV Hypervisor console cannot be "
-                           "used without z/VM.\n");
+                pr_info("The z/VM IUCV HVC device driver cannot "
+                           "be used without z/VM\n");
                 return -ENODEV;
         }
 
@@ -774,26 +900,33 @@ static int __init hvc_iucv_init(void)
                                            sizeof(struct iucv_tty_buffer),
                                            0, 0, NULL);
         if (!hvc_iucv_buffer_cache) {
-                pr_err("Not enough memory for driver initialization "
-                        "(rs=%d).\n", 1);
+                pr_err("Allocating memory failed with reason code=%d\n", 1);
                 return -ENOMEM;
         }
 
         hvc_iucv_mempool = mempool_create_slab_pool(MEMPOOL_MIN_NR,
                                                     hvc_iucv_buffer_cache);
         if (!hvc_iucv_mempool) {
-                pr_err("Not enough memory for driver initialization "
-                        "(rs=%d).\n", 2);
+                pr_err("Allocating memory failed with reason code=%d\n", 2);
                 kmem_cache_destroy(hvc_iucv_buffer_cache);
                 return -ENOMEM;
         }
 
+        /* register the first terminal device as console
+         * (must be done before allocating hvc terminal devices) */
+        rc = hvc_instantiate(HVC_IUCV_MAGIC, IUCV_HVC_CON_IDX, &hvc_iucv_ops);
+        if (rc) {
+                pr_err("Registering HVC terminal device as "
+                       "Linux console failed\n");
+                goto out_error_memory;
+        }
+
         /* allocate hvc_iucv_private structs */
         for (i = 0; i < hvc_iucv_devices; i++) {
-                rc = hvc_iucv_alloc(i);
+                rc = hvc_iucv_alloc(i, (i == IUCV_HVC_CON_IDX) ? 1 : 0);
                 if (rc) {
-                        pr_err("Could not create new z/VM IUCV HVC backend "
-                                "rc=%d.\n", rc);
+                        pr_err("Creating a new HVC terminal device "
+                                "failed with error code=%d\n", rc);
                         goto out_error_hvc;
                 }
         }
@@ -801,7 +934,8 @@ static int __init hvc_iucv_init(void)
         /* register IUCV callback handler */
         rc = iucv_register(&hvc_iucv_handler, 0);
         if (rc) {
-                pr_err("Could not register iucv handler (rc=%d).\n", rc);
+                pr_err("Registering IUCV handlers failed with error code=%d\n",
+                        rc);
                 goto out_error_iucv;
         }
 
@@ -816,22 +950,13 @@ out_error_hvc:
                                 hvc_remove(hvc_iucv_table[i]->hvc);
                         kfree(hvc_iucv_table[i]);
                 }
+out_error_memory:
         mempool_destroy(hvc_iucv_mempool);
         kmem_cache_destroy(hvc_iucv_buffer_cache);
         return rc;
 }
 
 /**
- * hvc_iucv_console_init() - Early console initialization
- */
-static  int __init hvc_iucv_console_init(void)
-{
-        if (!MACHINE_IS_VM || !hvc_iucv_devices)
-                return -ENODEV;
-        return hvc_instantiate(HVC_IUCV_MAGIC, 0, &hvc_iucv_ops);
-}
-
-/**
  * hvc_iucv_config() - Parsing of hvc_iucv=  kernel command line parameter
  * @val:        Parameter value (numeric)
  */
@@ -841,10 +966,5 @@ static	int __init hvc_iucv_config(char *val)
 }
 
 
-module_init(hvc_iucv_init);
-console_initcall(hvc_iucv_console_init);
+device_initcall(hvc_iucv_init);
 __setup("hvc_iucv=", hvc_iucv_config);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("HVC back-end for z/VM IUCV.");
-MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>");
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index e7fb7d2fcbfc..a4a1ae214630 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -63,6 +63,12 @@ config LEDS_WRAP
         help
           This option enables support for the PCEngines WRAP programmable LEDs.
 
+config LEDS_ALIX2
+        tristate "LED Support for ALIX.2 and ALIX.3 series"
+        depends on LEDS_CLASS && X86 && EXPERIMENTAL
+        help
+          This option enables support for the PCEngines ALIX.2 and ALIX.3 LEDs.
+
 config LEDS_H1940
         tristate "LED Support for iPAQ H1940 device"
         depends on LEDS_CLASS && ARCH_H1940
@@ -77,7 +83,7 @@ config LEDS_COBALT_QUBE
 
 config LEDS_COBALT_RAQ
         bool "LED Support for the Cobalt Raq series"
-        depends on LEDS_CLASS && MIPS_COBALT
+        depends on LEDS_CLASS=y && MIPS_COBALT
         select LEDS_TRIGGERS
         help
           This option enables support for the Cobalt Raq series LEDs.
@@ -158,6 +164,13 @@ config LEDS_PCA955X
           LED driver chips accessed via the I2C bus.  Supported
           devices include PCA9550, PCA9551, PCA9552, and PCA9553.
 
+config LEDS_WM8350
+        tristate "LED Support for WM8350 AudioPlus PMIC"
+        depends on LEDS_CLASS && MFD_WM8350
+        help
+          This option enables support for LEDs driven by the Wolfson
+          Microelectronics WM8350 AudioPlus PMIC.
+
 config LEDS_DA903X
         tristate "LED Support for DA9030/DA9034 PMIC"
         depends on LEDS_CLASS && PMIC_DA903X
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index e1967a29850e..bc247cb02e82 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -11,6 +11,7 @@ obj-$(CONFIG_LEDS_S3C24XX)		+= leds-s3c24xx.o
 obj-$(CONFIG_LEDS_AMS_DELTA)            += leds-ams-delta.o
 obj-$(CONFIG_LEDS_NET48XX)              += leds-net48xx.o
 obj-$(CONFIG_LEDS_WRAP)                 += leds-wrap.o
+obj-$(CONFIG_LEDS_ALIX2)                += leds-alix2.o
 obj-$(CONFIG_LEDS_H1940)                += leds-h1940.o
 obj-$(CONFIG_LEDS_COBALT_QUBE)          += leds-cobalt-qube.o
 obj-$(CONFIG_LEDS_COBALT_RAQ)           += leds-cobalt-raq.o
@@ -23,6 +24,7 @@ obj-$(CONFIG_LEDS_FSG)			+= leds-fsg.o
 obj-$(CONFIG_LEDS_PCA955X)              += leds-pca955x.o
 obj-$(CONFIG_LEDS_DA903X)               += leds-da903x.o
 obj-$(CONFIG_LEDS_HP_DISK)              += leds-hp-disk.o
+obj-$(CONFIG_LEDS_WM8350)               += leds-wm8350.o
 
 # LED Triggers
 obj-$(CONFIG_LEDS_TRIGGER_TIMER)        += ledtrig-timer.o
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index 6c4a326176d7..52f82e3ea13a 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -91,9 +91,29 @@ void led_classdev_resume(struct led_classdev *led_cdev)
 }
 EXPORT_SYMBOL_GPL(led_classdev_resume);
 
+static int led_suspend(struct device *dev, pm_message_t state)
+{
+        struct led_classdev *led_cdev = dev_get_drvdata(dev);
+
+        if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
+                led_classdev_suspend(led_cdev);
+
+        return 0;
+}
+
+static int led_resume(struct device *dev)
+{
+        struct led_classdev *led_cdev = dev_get_drvdata(dev);
+
+        if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
+                led_classdev_resume(led_cdev);
+
+        return 0;
+}
+
 /**
  * led_classdev_register - register a new object of led_classdev class.
- * @dev: The device to register.
+ * @parent: The device to register.
  * @led_cdev: the led_classdev structure for this device.
  */
 int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
@@ -174,6 +194,8 @@ static int __init leds_init(void)
         leds_class = class_create(THIS_MODULE, "leds");
         if (IS_ERR(leds_class))
                 return PTR_ERR(leds_class);
+        leds_class->suspend = led_suspend;
+        leds_class->resume = led_resume;
         return 0;
 }
 
diff --git a/drivers/leds/leds-alix2.c b/drivers/leds/leds-alix2.c
new file mode 100644
index 000000000000..ddbd7730dfc8
--- /dev/null
+++ b/drivers/leds/leds-alix2.c
@@ -0,0 +1,181 @@
+/*
+ * LEDs driver for PCEngines ALIX.2 and ALIX.3
+ *
+ * Copyright (C) 2008 Constantin Baranov <const@mimas.ru>
+ */
+
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/leds.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/string.h>
+
+static int force = 0;
+module_param(force, bool, 0444);
+MODULE_PARM_DESC(force, "Assume system has ALIX.2 style LEDs");
+
+struct alix_led {
+        struct led_classdev cdev;
+        unsigned short port;
+        unsigned int on_value;
+        unsigned int off_value;
+};
+
+static void alix_led_set(struct led_classdev *led_cdev,
+                         enum led_brightness brightness)
+{
+        struct alix_led *led_dev =
+                container_of(led_cdev, struct alix_led, cdev);
+
+        if (brightness)
+                outl(led_dev->on_value, led_dev->port);
+        else
+                outl(led_dev->off_value, led_dev->port);
+}
+
+static struct alix_led alix_leds[] = {
+        {
+                .cdev = {
+                        .name = "alix:1",
+                        .brightness_set = alix_led_set,
+                },
+                .port = 0x6100,
+                .on_value = 1 << 22,
+                .off_value = 1 << 6,
+        },
+        {
+                .cdev = {
+                        .name = "alix:2",
+                        .brightness_set = alix_led_set,
+                },
+                .port = 0x6180,
+                .on_value = 1 << 25,
+                .off_value = 1 << 9,
+        },
+        {
+                .cdev = {
+                        .name = "alix:3",
+                        .brightness_set = alix_led_set,
+                },
+                .port = 0x6180,
+                .on_value = 1 << 27,
+                .off_value = 1 << 11,
+        },
+};
+
+static int __init alix_led_probe(struct platform_device *pdev)
+{
+        int i;
+        int ret;
+
+        for (i = 0; i < ARRAY_SIZE(alix_leds); i++) {
+                alix_leds[i].cdev.flags |= LED_CORE_SUSPENDRESUME;
+                ret = led_classdev_register(&pdev->dev, &alix_leds[i].cdev);
+                if (ret < 0)
+                        goto fail;
+        }
+        return 0;
+
+fail:
+        while (--i >= 0)
+                led_classdev_unregister(&alix_leds[i].cdev);
+        return ret;
+}
+
+static int alix_led_remove(struct platform_device *pdev)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(alix_leds); i++)
+                led_classdev_unregister(&alix_leds[i].cdev);
+        return 0;
+}
+
+static struct platform_driver alix_led_driver = {
+        .remove = alix_led_remove,
+        .driver = {
+                .name = KBUILD_MODNAME,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init alix_present(void)
+{
+        const unsigned long bios_phys = 0x000f0000;
+        const size_t bios_len = 0x00010000;
+        const char alix_sig[] = "PC Engines ALIX.";
+        const size_t alix_sig_len = sizeof(alix_sig) - 1;
+
+        const char *bios_virt;
+        const char *scan_end;
+        const char *p;
+        int ret = 0;
+
+        if (force) {
+                printk(KERN_NOTICE "%s: forced to skip BIOS test, "
+                       "assume system has ALIX.2 style LEDs\n",
+                       KBUILD_MODNAME);
+                ret = 1;
+                goto out;
+        }
+
+        bios_virt = phys_to_virt(bios_phys);
+        scan_end = bios_virt + bios_len - (alix_sig_len + 2);
+        for (p = bios_virt; p < scan_end; p++) {
+                const char *tail;
+
+                if (memcmp(p, alix_sig, alix_sig_len) != 0) {
+                        continue;
+                }
+
+                tail = p + alix_sig_len;
+                if ((tail[0] == '2' || tail[0] == '3') && tail[1] == '\0') {
+                        printk(KERN_INFO
+                               "%s: system is recognized as \"%s\"\n",
+                               KBUILD_MODNAME, p);
+                        ret = 1;
+                        break;
+                }
+        }
+
+out:
+        return ret;
+}
+
+static struct platform_device *pdev;
+
+static int __init alix_led_init(void)
+{
+        int ret;
+
+        if (!alix_present()) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        pdev = platform_device_register_simple(KBUILD_MODNAME, -1, NULL, 0);
+        if (!IS_ERR(pdev)) {
+                ret = platform_driver_probe(&alix_led_driver, alix_led_probe);
+                if (ret)
+                        platform_device_unregister(pdev);
+        } else
+                ret = PTR_ERR(pdev);
+
+out:
+        return ret;
+}
+
+static void __exit alix_led_exit(void)
+{
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&alix_led_driver);
+}
+
+module_init(alix_led_init);
+module_exit(alix_led_exit);
+
+MODULE_AUTHOR("Constantin Baranov <const@mimas.ru>");
+MODULE_DESCRIPTION("PCEngines ALIX.2 and ALIX.3 LED driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/leds/leds-ams-delta.c b/drivers/leds/leds-ams-delta.c
index 1bd590bb3a6e..446050759b4d 100644
--- a/drivers/leds/leds-ams-delta.c
+++ b/drivers/leds/leds-ams-delta.c
@@ -79,37 +79,12 @@ static struct ams_delta_led ams_delta_leds[] = {
         },
 };
 
-#ifdef CONFIG_PM
-static int ams_delta_led_suspend(struct platform_device *dev,
-                pm_message_t state)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(ams_delta_leds); i++)
-                led_classdev_suspend(&ams_delta_leds[i].cdev);
-
-        return 0;
-}
-
-static int ams_delta_led_resume(struct platform_device *dev)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(ams_delta_leds); i++)
-                led_classdev_resume(&ams_delta_leds[i].cdev);
-
-        return 0;
-}
-#else
-#define ams_delta_led_suspend NULL
-#define ams_delta_led_resume NULL
-#endif
-
 static int ams_delta_led_probe(struct platform_device *pdev)
 {
         int i, ret;
 
         for (i = 0; i < ARRAY_SIZE(ams_delta_leds); i++) {
+                ams_delta_leds[i].cdev.flags |= LED_CORE_SUSPENDRESUME;
                 ret = led_classdev_register(&pdev->dev,
                                 &ams_delta_leds[i].cdev);
                 if (ret < 0)
@@ -127,7 +102,7 @@ static int ams_delta_led_remove(struct platform_device *pdev)
 {
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(ams_delta_leds); i--)
+        for (i = 0; i < ARRAY_SIZE(ams_delta_leds); i++)
                 led_classdev_unregister(&ams_delta_leds[i].cdev);
 
         return 0;
@@ -136,8 +111,6 @@ static int ams_delta_led_remove(struct platform_device *pdev)
 static struct platform_driver ams_delta_led_driver = {
         .probe          = ams_delta_led_probe,
         .remove         = ams_delta_led_remove,
-        .suspend        = ams_delta_led_suspend,
-        .resume         = ams_delta_led_resume,
         .driver         = {
                 .name = "ams-delta-led",
                 .owner = THIS_MODULE,
@@ -151,7 +124,7 @@ static int __init ams_delta_led_init(void)
 
 static void __exit ams_delta_led_exit(void)
 {
-        return platform_driver_unregister(&ams_delta_led_driver);
+        platform_driver_unregister(&ams_delta_led_driver);
 }
 
 module_init(ams_delta_led_init);
diff --git a/drivers/leds/leds-clevo-mail.c b/drivers/leds/leds-clevo-mail.c
index eb3415e88f43..1813c84ea5fc 100644
--- a/drivers/leds/leds-clevo-mail.c
+++ b/drivers/leds/leds-clevo-mail.c
@@ -142,6 +142,7 @@ static struct led_classdev clevo_mail_led = {
         .name                   = "clevo::mail",
         .brightness_set         = clevo_mail_led_set,
         .blink_set              = clevo_mail_led_blink,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static int __init clevo_mail_led_probe(struct platform_device *pdev)
@@ -155,29 +156,9 @@ static int clevo_mail_led_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int clevo_mail_led_suspend(struct platform_device *dev,
-                                  pm_message_t state)
-{
-        led_classdev_suspend(&clevo_mail_led);
-        return 0;
-}
-
-static int clevo_mail_led_resume(struct platform_device *dev)
-{
-        led_classdev_resume(&clevo_mail_led);
-        return 0;
-}
-#else
-#define clevo_mail_led_suspend    NULL
-#define clevo_mail_led_resume     NULL
-#endif
-
 static struct platform_driver clevo_mail_led_driver = {
         .probe          = clevo_mail_led_probe,
         .remove         = clevo_mail_led_remove,
-        .suspend        = clevo_mail_led_suspend,
-        .resume         = clevo_mail_led_resume,
         .driver         = {
                 .name           = KBUILD_MODNAME,
                 .owner          = THIS_MODULE,
diff --git a/drivers/leds/leds-fsg.c b/drivers/leds/leds-fsg.c
index 34935155c1c0..5f7c9c5c09b1 100644
--- a/drivers/leds/leds-fsg.c
+++ b/drivers/leds/leds-fsg.c
@@ -99,64 +99,43 @@ static void fsg_led_ring_set(struct led_classdev *led_cdev,
 }
 
 
-
 static struct led_classdev fsg_wlan_led = {
         .name                   = "fsg:blue:wlan",
         .brightness_set         = fsg_led_wlan_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static struct led_classdev fsg_wan_led = {
         .name                   = "fsg:blue:wan",
         .brightness_set         = fsg_led_wan_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static struct led_classdev fsg_sata_led = {
         .name                   = "fsg:blue:sata",
         .brightness_set         = fsg_led_sata_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static struct led_classdev fsg_usb_led = {
         .name                   = "fsg:blue:usb",
         .brightness_set         = fsg_led_usb_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static struct led_classdev fsg_sync_led = {
         .name                   = "fsg:blue:sync",
         .brightness_set         = fsg_led_sync_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static struct led_classdev fsg_ring_led = {
         .name                   = "fsg:blue:ring",
         .brightness_set         = fsg_led_ring_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 
-
-#ifdef CONFIG_PM
-static int fsg_led_suspend(struct platform_device *dev, pm_message_t state)
-{
-        led_classdev_suspend(&fsg_wlan_led);
-        led_classdev_suspend(&fsg_wan_led);
-        led_classdev_suspend(&fsg_sata_led);
-        led_classdev_suspend(&fsg_usb_led);
-        led_classdev_suspend(&fsg_sync_led);
-        led_classdev_suspend(&fsg_ring_led);
-        return 0;
-}
-
-static int fsg_led_resume(struct platform_device *dev)
-{
-        led_classdev_resume(&fsg_wlan_led);
-        led_classdev_resume(&fsg_wan_led);
-        led_classdev_resume(&fsg_sata_led);
-        led_classdev_resume(&fsg_usb_led);
-        led_classdev_resume(&fsg_sync_led);
-        led_classdev_resume(&fsg_ring_led);
-        return 0;
-}
-#endif
-
-
 static int fsg_led_probe(struct platform_device *pdev)
 {
         int ret;
@@ -232,10 +211,6 @@ static int fsg_led_remove(struct platform_device *pdev)
 static struct platform_driver fsg_led_driver = {
         .probe          = fsg_led_probe,
         .remove         = fsg_led_remove,
-#ifdef CONFIG_PM
-        .suspend        = fsg_led_suspend,
-        .resume         = fsg_led_resume,
-#endif
         .driver         = {
                 .name           = "fsg-led",
         },
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index b13bd2950e95..2e3df08b649b 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -105,6 +105,7 @@ static int gpio_led_probe(struct platform_device *pdev)
                 }
                 led_dat->cdev.brightness_set = gpio_led_set;
                 led_dat->cdev.brightness = LED_OFF;
+                led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
 
                 gpio_direction_output(led_dat->gpio, led_dat->active_low);
 
@@ -154,44 +155,9 @@ static int __devexit gpio_led_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int gpio_led_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
-        struct gpio_led_data *leds_data;
-        int i;
-
-        leds_data = platform_get_drvdata(pdev);
-
-        for (i = 0; i < pdata->num_leds; i++)
-                led_classdev_suspend(&leds_data[i].cdev);
-
-        return 0;
-}
-
-static int gpio_led_resume(struct platform_device *pdev)
-{
-        struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
-        struct gpio_led_data *leds_data;
-        int i;
-
-        leds_data = platform_get_drvdata(pdev);
-
-        for (i = 0; i < pdata->num_leds; i++)
-                led_classdev_resume(&leds_data[i].cdev);
-
-        return 0;
-}
-#else
-#define gpio_led_suspend NULL
-#define gpio_led_resume NULL
-#endif
-
 static struct platform_driver gpio_led_driver = {
         .probe          = gpio_led_probe,
         .remove         = __devexit_p(gpio_led_remove),
-        .suspend        = gpio_led_suspend,
-        .resume         = gpio_led_resume,
         .driver         = {
                 .name   = "leds-gpio",
                 .owner  = THIS_MODULE,
diff --git a/drivers/leds/leds-hp-disk.c b/drivers/leds/leds-hp-disk.c
index 44fa757d8254..d786adc8c5e3 100644
--- a/drivers/leds/leds-hp-disk.c
+++ b/drivers/leds/leds-hp-disk.c
@@ -68,25 +68,9 @@ static struct led_classdev hpled_led = {
         .name                   = "hp:red:hddprotection",
         .default_trigger        = "heartbeat",
         .brightness_set         = hpled_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
-#ifdef CONFIG_PM
-static int hpled_suspend(struct acpi_device *dev, pm_message_t state)
-{
-        led_classdev_suspend(&hpled_led);
-        return 0;
-}
-
-static int hpled_resume(struct acpi_device *dev)
-{
-        led_classdev_resume(&hpled_led);
-        return 0;
-}
-#else
-#define hpled_suspend NULL
-#define hpled_resume NULL
-#endif
-
 static int hpled_add(struct acpi_device *device)
 {
         int ret;
@@ -121,8 +105,6 @@ static struct acpi_driver leds_hp_driver = {
         .ops = {
                 .add     = hpled_add,
                 .remove  = hpled_remove,
-                .suspend = hpled_suspend,
-                .resume  = hpled_resume,
         }
 };
 
diff --git a/drivers/leds/leds-hp6xx.c b/drivers/leds/leds-hp6xx.c
index e8fb1baf8a50..e4ce1fd46338 100644
--- a/drivers/leds/leds-hp6xx.c
+++ b/drivers/leds/leds-hp6xx.c
@@ -45,30 +45,16 @@ static struct led_classdev hp6xx_red_led = {
         .name                   = "hp6xx:red",
         .default_trigger        = "hp6xx-charge",
         .brightness_set         = hp6xxled_red_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static struct led_classdev hp6xx_green_led = {
         .name                   = "hp6xx:green",
         .default_trigger        = "ide-disk",
         .brightness_set         = hp6xxled_green_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
-#ifdef CONFIG_PM
-static int hp6xxled_suspend(struct platform_device *dev, pm_message_t state)
-{
-        led_classdev_suspend(&hp6xx_red_led);
-        led_classdev_suspend(&hp6xx_green_led);
-        return 0;
-}
-
-static int hp6xxled_resume(struct platform_device *dev)
-{
-        led_classdev_resume(&hp6xx_red_led);
-        led_classdev_resume(&hp6xx_green_led);
-        return 0;
-}
-#endif
-
 static int hp6xxled_probe(struct platform_device *pdev)
 {
         int ret;
@@ -98,10 +84,6 @@ MODULE_ALIAS("platform:hp6xx-led");
 static struct platform_driver hp6xxled_driver = {
         .probe          = hp6xxled_probe,
         .remove         = hp6xxled_remove,
-#ifdef CONFIG_PM
-        .suspend        = hp6xxled_suspend,
-        .resume         = hp6xxled_resume,
-#endif
         .driver         = {
                 .name           = "hp6xx-led",
                 .owner          = THIS_MODULE,
diff --git a/drivers/leds/leds-net48xx.c b/drivers/leds/leds-net48xx.c
index 054360473c94..93987a12da49 100644
--- a/drivers/leds/leds-net48xx.c
+++ b/drivers/leds/leds-net48xx.c
@@ -33,26 +33,9 @@ static void net48xx_error_led_set(struct led_classdev *led_cdev,
 static struct led_classdev net48xx_error_led = {
         .name           = "net48xx::error",
         .brightness_set = net48xx_error_led_set,
+        .flags          = LED_CORE_SUSPENDRESUME,
 };
 
-#ifdef CONFIG_PM
-static int net48xx_led_suspend(struct platform_device *dev,
-                pm_message_t state)
-{
-        led_classdev_suspend(&net48xx_error_led);
-        return 0;
-}
-
-static int net48xx_led_resume(struct platform_device *dev)
-{
-        led_classdev_resume(&net48xx_error_led);
-        return 0;
-}
-#else
-#define net48xx_led_suspend NULL
-#define net48xx_led_resume NULL
-#endif
-
 static int net48xx_led_probe(struct platform_device *pdev)
 {
         return led_classdev_register(&pdev->dev, &net48xx_error_led);
@@ -67,8 +50,6 @@ static int net48xx_led_remove(struct platform_device *pdev)
 static struct platform_driver net48xx_led_driver = {
         .probe          = net48xx_led_probe,
         .remove         = net48xx_led_remove,
-        .suspend        = net48xx_led_suspend,
-        .resume         = net48xx_led_resume,
         .driver         = {
                 .name           = DRVNAME,
                 .owner          = THIS_MODULE,
diff --git a/drivers/leds/leds-pca9532.c b/drivers/leds/leds-pca9532.c
index 4064d4f6b33b..76ec7498e2d5 100644
--- a/drivers/leds/leds-pca9532.c
+++ b/drivers/leds/leds-pca9532.c
@@ -16,6 +16,7 @@
 #include <linux/leds.h>
 #include <linux/input.h>
 #include <linux/mutex.h>
+#include <linux/workqueue.h>
 #include <linux/leds-pca9532.h>
 
 static const unsigned short normal_i2c[] = { /*0x60,*/ I2C_CLIENT_END};
@@ -34,6 +35,7 @@ struct pca9532_data {
         struct pca9532_led leds[16];
         struct mutex update_lock;
         struct input_dev    *idev;
+       struct work_struct work;
         u8 pwm[2];
         u8 psc[2];
 };
@@ -63,7 +65,7 @@ static struct i2c_driver pca9532_driver = {
  * as a compromise we average one pwm to the values requested by all
  * leds that are not ON/OFF.
  * */
-static int pca9532_setpwm(struct i2c_client *client, int pwm, int blink,
+static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink,
         enum led_brightness value)
 {
         int a = 0, b = 0, i = 0;
@@ -84,11 +86,17 @@ static int pca9532_setpwm(struct i2c_client *client, int pwm, int blink,
         b = b/a;
         if (b > 0xFF)
                 return -EINVAL;
-        mutex_lock(&data->update_lock);
         data->pwm[pwm] = b;
+       data->psc[pwm] = blink;
+       return 0;
+}
+
+static int pca9532_setpwm(struct i2c_client *client, int pwm)
+{
+       struct pca9532_data *data = i2c_get_clientdata(client);
+       mutex_lock(&data->update_lock);
         i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(pwm),
                 data->pwm[pwm]);
-        data->psc[pwm] = blink;
         i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(pwm),
                 data->psc[pwm]);
         mutex_unlock(&data->update_lock);
@@ -124,11 +132,11 @@ static void pca9532_set_brightness(struct led_classdev *led_cdev,
                 led->state = PCA9532_ON;
         else {
                 led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */
-                err = pca9532_setpwm(led->client, 0, 0, value);
+               err = pca9532_calcpwm(led->client, 0, 0, value);
                 if (err)
                         return; /* XXX: led api doesn't allow error code? */
         }
-        pca9532_setled(led);
+       schedule_work(&led->work);
 }
 
 static int pca9532_set_blink(struct led_classdev *led_cdev,
@@ -137,6 +145,7 @@ static int pca9532_set_blink(struct led_classdev *led_cdev,
         struct pca9532_led *led = ldev_to_led(led_cdev);
         struct i2c_client *client = led->client;
         int psc;
+       int err = 0;
 
         if (*delay_on == 0 && *delay_off == 0) {
         /* led subsystem ask us for a blink rate */
@@ -148,11 +157,15 @@ static int pca9532_set_blink(struct led_classdev *led_cdev,
 
         /* Thecus specific: only use PSC/PWM 0 */
         psc = (*delay_on * 152-1)/1000;
-        return pca9532_setpwm(client, 0, psc, led_cdev->brightness);
+       err = pca9532_calcpwm(client, 0, psc, led_cdev->brightness);
+       if (err)
+               return err;
+       schedule_work(&led->work);
+       return 0;
 }
 
-int pca9532_event(struct input_dev *dev, unsigned int type, unsigned int code,
-        int value)
+static int pca9532_event(struct input_dev *dev, unsigned int type,
+        unsigned int code, int value)
 {
         struct pca9532_data *data = input_get_drvdata(dev);
 
@@ -165,13 +178,28 @@ int pca9532_event(struct input_dev *dev, unsigned int type, unsigned int code,
         else
                 data->pwm[1] = 0;
 
-        dev_info(&dev->dev, "setting beep to %d \n", data->pwm[1]);
+       schedule_work(&data->work);
+
+       return 0;
+}
+
+static void pca9532_input_work(struct work_struct *work)
+{
+       struct pca9532_data *data;
+       data = container_of(work, struct pca9532_data, work);
         mutex_lock(&data->update_lock);
         i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(1),
                 data->pwm[1]);
         mutex_unlock(&data->update_lock);
+}
 
-        return 0;
+static void pca9532_led_work(struct work_struct *work)
+{
+       struct pca9532_led *led;
+       led = container_of(work, struct pca9532_led, work);
+       if (led->state == PCA9532_PWM0)
+               pca9532_setpwm(led->client, 0);
+       pca9532_setled(led);
 }
 
 static int pca9532_configure(struct i2c_client *client,
@@ -204,8 +232,9 @@ static int pca9532_configure(struct i2c_client *client,
                         led->ldev.brightness = LED_OFF;
                         led->ldev.brightness_set = pca9532_set_brightness;
                         led->ldev.blink_set = pca9532_set_blink;
-                        if (led_classdev_register(&client->dev,
-                                &led->ldev) < 0)        {
+                       INIT_WORK(&led->work, pca9532_led_work);
+                        err = led_classdev_register(&client->dev, &led->ldev);
+                        if (err < 0) {
                                 dev_err(&client->dev,
                                         "couldn't register LED %s\n",
                                         led->name);
@@ -233,9 +262,11 @@ static int pca9532_configure(struct i2c_client *client,
                                                 BIT_MASK(SND_TONE);
                         data->idev->event = pca9532_event;
                         input_set_drvdata(data->idev, data);
+                       INIT_WORK(&data->work, pca9532_input_work);
                         err = input_register_device(data->idev);
                         if (err) {
                                 input_free_device(data->idev);
+                               cancel_work_sync(&data->work);
                                 data->idev = NULL;
                                 goto exit;
                         }
@@ -252,18 +283,19 @@ exit:
                                 break;
                         case PCA9532_TYPE_LED:
                                 led_classdev_unregister(&data->leds[i].ldev);
+                               cancel_work_sync(&data->leds[i].work);
                                 break;
                         case PCA9532_TYPE_N2100_BEEP:
                                 if (data->idev != NULL) {
                                         input_unregister_device(data->idev);
                                         input_free_device(data->idev);
+                                       cancel_work_sync(&data->work);
                                         data->idev = NULL;
                                 }
                                 break;
                         }
 
         return err;
-
 }
 
 static int pca9532_probe(struct i2c_client *client,
@@ -271,12 +303,16 @@ static int pca9532_probe(struct i2c_client *client,
 {
         struct pca9532_data *data = i2c_get_clientdata(client);
         struct pca9532_platform_data *pca9532_pdata = client->dev.platform_data;
+        int err;
+
+        if (!pca9532_pdata)
+                return -EIO;
 
         if (!i2c_check_functionality(client->adapter,
                 I2C_FUNC_SMBUS_BYTE_DATA))
                 return -EIO;
 
-        data = kzalloc(sizeof(struct pca9532_data), GFP_KERNEL);
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
@@ -285,12 +321,13 @@ static int pca9532_probe(struct i2c_client *client,
         data->client = client;
         mutex_init(&data->update_lock);
 
-        if (pca9532_pdata == NULL)
-                return -EIO;
-
-        pca9532_configure(client, data, pca9532_pdata);
-        return 0;
+        err = pca9532_configure(client, data, pca9532_pdata);
+        if (err) {
+                kfree(data);
+                i2c_set_clientdata(client, NULL);
+        }
 
+        return err;
 }
 
 static int pca9532_remove(struct i2c_client *client)
@@ -303,11 +340,13 @@ static int pca9532_remove(struct i2c_client *client)
                         break;
                 case PCA9532_TYPE_LED:
                         led_classdev_unregister(&data->leds[i].ldev);
+                       cancel_work_sync(&data->leds[i].work);
                         break;
                 case PCA9532_TYPE_N2100_BEEP:
                         if (data->idev != NULL) {
                                 input_unregister_device(data->idev);
                                 input_free_device(data->idev);
+                               cancel_work_sync(&data->work);
                                 data->idev = NULL;
                         }
                         break;
diff --git a/drivers/leds/leds-s3c24xx.c b/drivers/leds/leds-s3c24xx.c
index 25a07f2643ad..4d81131542ae 100644
--- a/drivers/leds/leds-s3c24xx.c
+++ b/drivers/leds/leds-s3c24xx.c
@@ -82,6 +82,7 @@ static int s3c24xx_led_probe(struct platform_device *dev)
         led->cdev.brightness_set = s3c24xx_led_set;
         led->cdev.default_trigger = pdata->def_trigger;
         led->cdev.name = pdata->name;
+        led->cdev.flags |= LED_CORE_SUSPENDRESUME;
 
         led->pdata = pdata;
 
@@ -111,33 +112,9 @@ static int s3c24xx_led_probe(struct platform_device *dev)
         return ret;
 }
 
-
-#ifdef CONFIG_PM
-static int s3c24xx_led_suspend(struct platform_device *dev, pm_message_t state)
-{
-        struct s3c24xx_gpio_led *led = pdev_to_gpio(dev);
-
-        led_classdev_suspend(&led->cdev);
-        return 0;
-}
-
-static int s3c24xx_led_resume(struct platform_device *dev)
-{
-        struct s3c24xx_gpio_led *led = pdev_to_gpio(dev);
-
-        led_classdev_resume(&led->cdev);
-        return 0;
-}
-#else
-#define s3c24xx_led_suspend NULL
-#define s3c24xx_led_resume NULL
-#endif
-
 static struct platform_driver s3c24xx_led_driver = {
         .probe          = s3c24xx_led_probe,
         .remove         = s3c24xx_led_remove,
-        .suspend        = s3c24xx_led_suspend,
-        .resume         = s3c24xx_led_resume,
         .driver         = {
                 .name           = "s3c24xx_led",
                 .owner          = THIS_MODULE,
diff --git a/drivers/leds/leds-wm8350.c b/drivers/leds/leds-wm8350.c
new file mode 100644
index 000000000000..38c6bcb07e6c
--- /dev/null
+++ b/drivers/leds/leds-wm8350.c
@@ -0,0 +1,311 @@
+/*
+ * LED driver for WM8350 driven LEDS.
+ *
+ * Copyright(C) 2007, 2008 Wolfson Microelectronics PLC.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/leds.h>
+#include <linux/err.h>
+#include <linux/mfd/wm8350/pmic.h>
+#include <linux/regulator/consumer.h>
+
+/* Microamps */
+static const int isink_cur[] = {
+        4,
+        5,
+        6,
+        7,
+        8,
+        10,
+        11,
+        14,
+        16,
+        19,
+        23,
+        27,
+        32,
+        39,
+        46,
+        54,
+        65,
+        77,
+        92,
+        109,
+        130,
+        154,
+        183,
+        218,
+        259,
+        308,
+        367,
+        436,
+        518,
+        616,
+        733,
+        872,
+        1037,
+        1233,
+        1466,
+        1744,
+        2073,
+        2466,
+        2933,
+        3487,
+        4147,
+        4932,
+        5865,
+        6975,
+        8294,
+        9864,
+        11730,
+        13949,
+        16589,
+        19728,
+        23460,
+        27899,
+        33178,
+        39455,
+        46920,
+        55798,
+        66355,
+        78910,
+        93840,
+        111596,
+        132710,
+        157820,
+        187681,
+        223191
+};
+
+#define to_wm8350_led(led_cdev) \
+        container_of(led_cdev, struct wm8350_led, cdev)
+
+static void wm8350_led_enable(struct wm8350_led *led)
+{
+        int ret;
+
+        if (led->enabled)
+                return;
+
+        ret = regulator_enable(led->isink);
+        if (ret != 0) {
+                dev_err(led->cdev.dev, "Failed to enable ISINK: %d\n", ret);
+                return;
+        }
+
+        ret = regulator_enable(led->dcdc);
+        if (ret != 0) {
+                dev_err(led->cdev.dev, "Failed to enable DCDC: %d\n", ret);
+                regulator_disable(led->isink);
+                return;
+        }
+
+        led->enabled = 1;
+}
+
+static void wm8350_led_disable(struct wm8350_led *led)
+{
+        int ret;
+
+        if (!led->enabled)
+                return;
+
+        ret = regulator_disable(led->dcdc);
+        if (ret != 0) {
+                dev_err(led->cdev.dev, "Failed to disable DCDC: %d\n", ret);
+                return;
+        }
+
+        ret = regulator_disable(led->isink);
+        if (ret != 0) {
+                dev_err(led->cdev.dev, "Failed to disable ISINK: %d\n", ret);
+                regulator_enable(led->dcdc);
+                return;
+        }
+
+        led->enabled = 0;
+}
+
+static void led_work(struct work_struct *work)
+{
+        struct wm8350_led *led = container_of(work, struct wm8350_led, work);
+        int ret;
+        int uA;
+        unsigned long flags;
+
+        mutex_lock(&led->mutex);
+
+        spin_lock_irqsave(&led->value_lock, flags);
+
+        if (led->value == LED_OFF) {
+                spin_unlock_irqrestore(&led->value_lock, flags);
+                wm8350_led_disable(led);
+                goto out;
+        }
+
+        /* This scales linearly into the index of valid current
+         * settings which results in a linear scaling of perceived
+         * brightness due to the non-linear current settings provided
+         * by the hardware.
+         */
+        uA = (led->max_uA_index * led->value) / LED_FULL;
+        spin_unlock_irqrestore(&led->value_lock, flags);
+        BUG_ON(uA >= ARRAY_SIZE(isink_cur));
+
+        ret = regulator_set_current_limit(led->isink, isink_cur[uA],
+                                          isink_cur[uA]);
+        if (ret != 0)
+                dev_err(led->cdev.dev, "Failed to set %duA: %d\n",
+                        isink_cur[uA], ret);
+
+        wm8350_led_enable(led);
+
+out:
+        mutex_unlock(&led->mutex);
+}
+
+static void wm8350_led_set(struct led_classdev *led_cdev,
+                           enum led_brightness value)
+{
+        struct wm8350_led *led = to_wm8350_led(led_cdev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&led->value_lock, flags);
+        led->value = value;
+        schedule_work(&led->work);
+        spin_unlock_irqrestore(&led->value_lock, flags);
+}
+
+static void wm8350_led_shutdown(struct platform_device *pdev)
+{
+        struct wm8350_led *led = platform_get_drvdata(pdev);
+
+        mutex_lock(&led->mutex);
+        led->value = LED_OFF;
+        wm8350_led_disable(led);
+        mutex_unlock(&led->mutex);
+}
+
+static int wm8350_led_probe(struct platform_device *pdev)
+{
+        struct regulator *isink, *dcdc;
+        struct wm8350_led *led;
+        struct wm8350_led_platform_data *pdata = pdev->dev.platform_data;
+        int ret, i;
+
+        if (pdata == NULL) {
+                dev_err(&pdev->dev, "no platform data\n");
+                return -ENODEV;
+        }
+
+        if (pdata->max_uA < isink_cur[0]) {
+                dev_err(&pdev->dev, "Invalid maximum current %duA\n",
+                        pdata->max_uA);
+                return -EINVAL;
+        }
+
+        isink = regulator_get(&pdev->dev, "led_isink");
+        if (IS_ERR(isink)) {
+                printk(KERN_ERR "%s: cant get ISINK\n", __func__);
+                return PTR_ERR(isink);
+        }
+
+        dcdc = regulator_get(&pdev->dev, "led_vcc");
+        if (IS_ERR(dcdc)) {
+                printk(KERN_ERR "%s: cant get DCDC\n", __func__);
+                ret = PTR_ERR(dcdc);
+                goto err_isink;
+        }
+
+        led = kzalloc(sizeof(*led), GFP_KERNEL);
+        if (led == NULL) {
+                ret = -ENOMEM;
+                goto err_dcdc;
+        }
+
+        led->cdev.brightness_set = wm8350_led_set;
+        led->cdev.default_trigger = pdata->default_trigger;
+        led->cdev.name = pdata->name;
+        led->cdev.flags |= LED_CORE_SUSPENDRESUME;
+        led->enabled = regulator_is_enabled(isink);
+        led->isink = isink;
+        led->dcdc = dcdc;
+
+        for (i = 0; i < ARRAY_SIZE(isink_cur) - 1; i++)
+                if (isink_cur[i] >= pdata->max_uA)
+                        break;
+        led->max_uA_index = i;
+        if (pdata->max_uA != isink_cur[i])
+                dev_warn(&pdev->dev,
+                         "Maximum current %duA is not directly supported,"
+                         " check platform data\n",
+                         pdata->max_uA);
+
+        spin_lock_init(&led->value_lock);
+        mutex_init(&led->mutex);
+        INIT_WORK(&led->work, led_work);
+        led->value = LED_OFF;
+        platform_set_drvdata(pdev, led);
+
+        ret = led_classdev_register(&pdev->dev, &led->cdev);
+        if (ret < 0)
+                goto err_led;
+
+        return 0;
+
+ err_led:
+        kfree(led);
+ err_dcdc:
+        regulator_put(dcdc);
+ err_isink:
+        regulator_put(isink);
+        return ret;
+}
+
+static int wm8350_led_remove(struct platform_device *pdev)
+{
+        struct wm8350_led *led = platform_get_drvdata(pdev);
+
+        led_classdev_unregister(&led->cdev);
+        flush_scheduled_work();
+        wm8350_led_disable(led);
+        regulator_put(led->dcdc);
+        regulator_put(led->isink);
+        kfree(led);
+        return 0;
+}
+
+static struct platform_driver wm8350_led_driver = {
+        .driver = {
+                   .name = "wm8350-led",
+                   .owner = THIS_MODULE,
+                   },
+        .probe = wm8350_led_probe,
+        .remove = wm8350_led_remove,
+        .shutdown = wm8350_led_shutdown,
+};
+
+static int __devinit wm8350_led_init(void)
+{
+        return platform_driver_register(&wm8350_led_driver);
+}
+module_init(wm8350_led_init);
+
+static void wm8350_led_exit(void)
+{
+        platform_driver_unregister(&wm8350_led_driver);
+}
+module_exit(wm8350_led_exit);
+
+MODULE_AUTHOR("Mark Brown");
+MODULE_DESCRIPTION("WM8350 LED driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm8350-led");
diff --git a/drivers/leds/leds-wrap.c b/drivers/leds/leds-wrap.c
index 2f3aa87f2a1f..2982c86ac4cf 100644
--- a/drivers/leds/leds-wrap.c
+++ b/drivers/leds/leds-wrap.c
@@ -56,40 +56,21 @@ static struct led_classdev wrap_power_led = {
         .name                   = "wrap::power",
         .brightness_set         = wrap_power_led_set,
         .default_trigger        = "default-on",
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static struct led_classdev wrap_error_led = {
         .name           = "wrap::error",
         .brightness_set = wrap_error_led_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
 static struct led_classdev wrap_extra_led = {
         .name           = "wrap::extra",
         .brightness_set = wrap_extra_led_set,
+        .flags                  = LED_CORE_SUSPENDRESUME,
 };
 
-#ifdef CONFIG_PM
-static int wrap_led_suspend(struct platform_device *dev,
-                pm_message_t state)
-{
-        led_classdev_suspend(&wrap_power_led);
-        led_classdev_suspend(&wrap_error_led);
-        led_classdev_suspend(&wrap_extra_led);
-        return 0;
-}
-
-static int wrap_led_resume(struct platform_device *dev)
-{
-        led_classdev_resume(&wrap_power_led);
-        led_classdev_resume(&wrap_error_led);
-        led_classdev_resume(&wrap_extra_led);
-        return 0;
-}
-#else
-#define wrap_led_suspend NULL
-#define wrap_led_resume NULL
-#endif
-
 static int wrap_led_probe(struct platform_device *pdev)
 {
         int ret;
@@ -127,8 +108,6 @@ static int wrap_led_remove(struct platform_device *pdev)
 static struct platform_driver wrap_led_driver = {
         .probe          = wrap_led_probe,
         .remove         = wrap_led_remove,
-        .suspend        = wrap_led_suspend,
-        .resume         = wrap_led_resume,
         .driver         = {
                 .name           = DRVNAME,
                 .owner          = THIS_MODULE,
diff --git a/drivers/leds/ledtrig-timer.c b/drivers/leds/ledtrig-timer.c
index db681962d7bb..3d6531396dda 100644
--- a/drivers/leds/ledtrig-timer.c
+++ b/drivers/leds/ledtrig-timer.c
@@ -199,6 +199,7 @@ err_out:
 static void timer_trig_deactivate(struct led_classdev *led_cdev)
 {
         struct timer_trig_data *timer_data = led_cdev->trigger_data;
+        unsigned long on = 0, off = 0;
 
         if (timer_data) {
                 device_remove_file(led_cdev->dev, &dev_attr_delay_on);
@@ -206,6 +207,10 @@ static void timer_trig_deactivate(struct led_classdev *led_cdev)
                 del_timer_sync(&timer_data->timer);
                 kfree(timer_data);
         }
+
+        /* If there is hardware support for blinking, stop it */
+        if (led_cdev->blink_set)
+                led_cdev->blink_set(led_cdev, &on, &off);
 }
 
 static struct led_trigger timer_led_trigger = {
diff --git a/drivers/mfd/wm8350-core.c b/drivers/mfd/wm8350-core.c
index 3a273ccef3f2..f92595c8f165 100644
--- a/drivers/mfd/wm8350-core.c
+++ b/drivers/mfd/wm8350-core.c
@@ -1453,6 +1453,9 @@ void wm8350_device_exit(struct wm8350 *wm8350)
 {
         int i;
 
+        for (i = 0; i < ARRAY_SIZE(wm8350->pmic.led); i++)
+                platform_device_unregister(wm8350->pmic.led[i].pdev);
+
         for (i = 0; i < ARRAY_SIZE(wm8350->pmic.pdev); i++)
                 platform_device_unregister(wm8350->pmic.pdev[i]);
 
diff --git a/drivers/oprofile/buffer_sync.c b/drivers/oprofile/buffer_sync.c
index 65e8294a9e29..9da5a4b81133 100644
--- a/drivers/oprofile/buffer_sync.c
+++ b/drivers/oprofile/buffer_sync.c
@@ -1,11 +1,12 @@
 /**
  * @file buffer_sync.c
  *
- * @remark Copyright 2002 OProfile authors
+ * @remark Copyright 2002-2009 OProfile authors
  * @remark Read the file COPYING
  *
  * @author John Levon <levon@movementarian.org>
  * @author Barry Kasindorf
+ * @author Robert Richter <robert.richter@amd.com>
  *
  * This is the core of the buffer management. Each
  * CPU buffer is processed and entered into the
@@ -315,88 +316,73 @@ static void add_trace_begin(void)
         add_event_entry(TRACE_BEGIN_CODE);
 }
 
-#ifdef CONFIG_OPROFILE_IBS
-
-#define IBS_FETCH_CODE_SIZE     2
-#define IBS_OP_CODE_SIZE        5
-
-/*
- * Add IBS fetch and op entries to event buffer
- */
-static void add_ibs_begin(int cpu, int code, struct mm_struct *mm)
+static void add_data(struct op_entry *entry, struct mm_struct *mm)
 {
-        unsigned long rip;
-        int i, count;
-        unsigned long ibs_cookie = 0;
+        unsigned long code, pc, val;
+        unsigned long cookie;
         off_t offset;
-        struct op_sample *sample;
-
-        sample = cpu_buffer_read_entry(cpu);
-        if (!sample)
-                goto Error;
-        rip = sample->eip;
 
-#ifdef __LP64__
-        rip += sample->event << 32;
-#endif
+        if (!op_cpu_buffer_get_data(entry, &code))
+                return;
+        if (!op_cpu_buffer_get_data(entry, &pc))
+                return;
+        if (!op_cpu_buffer_get_size(entry))
+                return;
 
         if (mm) {
-                ibs_cookie = lookup_dcookie(mm, rip, &offset);
+                cookie = lookup_dcookie(mm, pc, &offset);
 
-                if (ibs_cookie == NO_COOKIE)
-                        offset = rip;
-                if (ibs_cookie == INVALID_COOKIE) {
+                if (cookie == NO_COOKIE)
+                        offset = pc;
+                if (cookie == INVALID_COOKIE) {
                         atomic_inc(&oprofile_stats.sample_lost_no_mapping);
-                        offset = rip;
+                        offset = pc;
                 }
-                if (ibs_cookie != last_cookie) {
-                        add_cookie_switch(ibs_cookie);
-                        last_cookie = ibs_cookie;
+                if (cookie != last_cookie) {
+                        add_cookie_switch(cookie);
+                        last_cookie = cookie;
                 }
         } else
-                offset = rip;
+                offset = pc;
 
         add_event_entry(ESCAPE_CODE);
         add_event_entry(code);
         add_event_entry(offset);        /* Offset from Dcookie */
 
-        /* we send the Dcookie offset, but send the raw Linear Add also*/
-        add_event_entry(sample->eip);
-        add_event_entry(sample->event);
-
-        if (code == IBS_FETCH_CODE)
-                count = IBS_FETCH_CODE_SIZE;    /*IBS FETCH is 2 int64s*/
-        else
-                count = IBS_OP_CODE_SIZE;       /*IBS OP is 5 int64s*/
-
-        for (i = 0; i < count; i++) {
-                sample = cpu_buffer_read_entry(cpu);
-                if (!sample)
-                        goto Error;
-                add_event_entry(sample->eip);
-                add_event_entry(sample->event);
-        }
-
-        return;
-
-Error:
-        return;
+        while (op_cpu_buffer_get_data(entry, &val))
+                add_event_entry(val);
 }
 
-#endif
-
-static void add_sample_entry(unsigned long offset, unsigned long event)
+static inline void add_sample_entry(unsigned long offset, unsigned long event)
 {
         add_event_entry(offset);
         add_event_entry(event);
 }
 
 
-static int add_us_sample(struct mm_struct *mm, struct op_sample *s)
+/*
+ * Add a sample to the global event buffer. If possible the
+ * sample is converted into a persistent dentry/offset pair
+ * for later lookup from userspace. Return 0 on failure.
+ */
+static int
+add_sample(struct mm_struct *mm, struct op_sample *s, int in_kernel)
 {
         unsigned long cookie;
         off_t offset;
 
+        if (in_kernel) {
+                add_sample_entry(s->eip, s->event);
+                return 1;
+        }
+
+        /* add userspace sample */
+
+        if (!mm) {
+                atomic_inc(&oprofile_stats.sample_lost_no_mm);
+                return 0;
+        }
+
         cookie = lookup_dcookie(mm, s->eip, &offset);
 
         if (cookie == INVALID_COOKIE) {
@@ -415,25 +401,6 @@ static int add_us_sample(struct mm_struct *mm, struct op_sample *s)
 }
 
 
-/* Add a sample to the global event buffer. If possible the
- * sample is converted into a persistent dentry/offset pair
- * for later lookup from userspace.
- */
-static int
-add_sample(struct mm_struct *mm, struct op_sample *s, int in_kernel)
-{
-        if (in_kernel) {
-                add_sample_entry(s->eip, s->event);
-                return 1;
-        } else if (mm) {
-                return add_us_sample(mm, s);
-        } else {
-                atomic_inc(&oprofile_stats.sample_lost_no_mm);
-        }
-        return 0;
-}
-
-
 static void release_mm(struct mm_struct *mm)
 {
         if (!mm)
@@ -526,66 +493,69 @@ void sync_buffer(int cpu)
 {
         struct mm_struct *mm = NULL;
         struct mm_struct *oldmm;
+        unsigned long val;
         struct task_struct *new;
         unsigned long cookie = 0;
         int in_kernel = 1;
         sync_buffer_state state = sb_buffer_start;
         unsigned int i;
         unsigned long available;
+        unsigned long flags;
+        struct op_entry entry;
+        struct op_sample *sample;
 
         mutex_lock(&buffer_mutex);
 
         add_cpu_switch(cpu);
 
-        cpu_buffer_reset(cpu);
-        available = cpu_buffer_entries(cpu);
+        op_cpu_buffer_reset(cpu);
+        available = op_cpu_buffer_entries(cpu);
 
         for (i = 0; i < available; ++i) {
-                struct op_sample *s = cpu_buffer_read_entry(cpu);
-                if (!s)
+                sample = op_cpu_buffer_read_entry(&entry, cpu);
+                if (!sample)
                         break;
 
-                if (is_code(s->eip)) {
-                        switch (s->event) {
-                        case 0:
-                        case CPU_IS_KERNEL:
+                if (is_code(sample->eip)) {
+                        flags = sample->event;
+                        if (flags & TRACE_BEGIN) {
+                                state = sb_bt_start;
+                                add_trace_begin();
+                        }
+                        if (flags & KERNEL_CTX_SWITCH) {
                                 /* kernel/userspace switch */
-                                in_kernel = s->event;
+                                in_kernel = flags & IS_KERNEL;
                                 if (state == sb_buffer_start)
                                         state = sb_sample_start;
-                                add_kernel_ctx_switch(s->event);
-                                break;
-                        case CPU_TRACE_BEGIN:
-                                state = sb_bt_start;
-                                add_trace_begin();
-                                break;
-#ifdef CONFIG_OPROFILE_IBS
-                        case IBS_FETCH_BEGIN:
-                                state = sb_bt_start;
-                                add_ibs_begin(cpu, IBS_FETCH_CODE, mm);
-                                break;
-                        case IBS_OP_BEGIN:
-                                state = sb_bt_start;
-                                add_ibs_begin(cpu, IBS_OP_CODE, mm);
-                                break;
-#endif
-                        default:
+                                add_kernel_ctx_switch(flags & IS_KERNEL);
+                        }
+                        if (flags & USER_CTX_SWITCH
+                            && op_cpu_buffer_get_data(&entry, &val)) {
                                 /* userspace context switch */
+                                new = (struct task_struct *)val;
                                 oldmm = mm;
-                                new = (struct task_struct *)s->event;
                                 release_mm(oldmm);
                                 mm = take_tasks_mm(new);
                                 if (mm != oldmm)
                                         cookie = get_exec_dcookie(mm);
                                 add_user_ctx_switch(new, cookie);
-                                break;
-                        }
-                } else if (state >= sb_bt_start &&
-                           !add_sample(mm, s, in_kernel)) {
-                        if (state == sb_bt_start) {
-                                state = sb_bt_ignore;
-                                atomic_inc(&oprofile_stats.bt_lost_no_mapping);
                         }
+                        if (op_cpu_buffer_get_size(&entry))
+                                add_data(&entry, mm);
+                        continue;
+                }
+
+                if (state < sb_bt_start)
+                        /* ignore sample */
+                        continue;
+
+                if (add_sample(mm, sample, in_kernel))
+                        continue;
+
+                /* ignore backtraces if failed to add a sample */
+                if (state == sb_bt_start) {
+                        state = sb_bt_ignore;
+                        atomic_inc(&oprofile_stats.bt_lost_no_mapping);
                 }
         }
         release_mm(mm);
diff --git a/drivers/oprofile/cpu_buffer.c b/drivers/oprofile/cpu_buffer.c
index 61090969158f..2e03b6d796d3 100644
--- a/drivers/oprofile/cpu_buffer.c
+++ b/drivers/oprofile/cpu_buffer.c
@@ -1,11 +1,12 @@
 /**
  * @file cpu_buffer.c
  *
- * @remark Copyright 2002 OProfile authors
+ * @remark Copyright 2002-2009 OProfile authors
  * @remark Read the file COPYING
  *
  * @author John Levon <levon@movementarian.org>
  * @author Barry Kasindorf <barry.kasindorf@amd.com>
+ * @author Robert Richter <robert.richter@amd.com>
  *
  * Each CPU has a local buffer that stores PC value/event
  * pairs. We also log context switches when we notice them.
@@ -45,8 +46,8 @@
  * can be changed to a single buffer solution when the ring buffer
  * access is implemented as non-locking atomic code.
  */
-struct ring_buffer *op_ring_buffer_read;
-struct ring_buffer *op_ring_buffer_write;
+static struct ring_buffer *op_ring_buffer_read;
+static struct ring_buffer *op_ring_buffer_write;
 DEFINE_PER_CPU(struct oprofile_cpu_buffer, cpu_buffer);
 
 static void wq_sync_buffer(struct work_struct *work);
@@ -54,19 +55,9 @@ static void wq_sync_buffer(struct work_struct *work);
 #define DEFAULT_TIMER_EXPIRE (HZ / 10)
 static int work_enabled;
 
-void free_cpu_buffers(void)
-{
-        if (op_ring_buffer_read)
-                ring_buffer_free(op_ring_buffer_read);
-        op_ring_buffer_read = NULL;
-        if (op_ring_buffer_write)
-                ring_buffer_free(op_ring_buffer_write);
-        op_ring_buffer_write = NULL;
-}
-
 unsigned long oprofile_get_cpu_buffer_size(void)
 {
-        return fs_cpu_buffer_size;
+        return oprofile_cpu_buffer_size;
 }
 
 void oprofile_cpu_buffer_inc_smpl_lost(void)
@@ -77,11 +68,21 @@ void oprofile_cpu_buffer_inc_smpl_lost(void)
         cpu_buf->sample_lost_overflow++;
 }
 
+void free_cpu_buffers(void)
+{
+        if (op_ring_buffer_read)
+                ring_buffer_free(op_ring_buffer_read);
+        op_ring_buffer_read = NULL;
+        if (op_ring_buffer_write)
+                ring_buffer_free(op_ring_buffer_write);
+        op_ring_buffer_write = NULL;
+}
+
 int alloc_cpu_buffers(void)
 {
         int i;
 
-        unsigned long buffer_size = fs_cpu_buffer_size;
+        unsigned long buffer_size = oprofile_cpu_buffer_size;
 
         op_ring_buffer_read = ring_buffer_alloc(buffer_size, OP_BUFFER_FLAGS);
         if (!op_ring_buffer_read)
@@ -97,8 +98,6 @@ int alloc_cpu_buffers(void)
                 b->last_is_kernel = -1;
                 b->tracing = 0;
                 b->buffer_size = buffer_size;
-                b->tail_pos = 0;
-                b->head_pos = 0;
                 b->sample_received = 0;
                 b->sample_lost_overflow = 0;
                 b->backtrace_aborted = 0;
@@ -145,47 +144,156 @@ void end_cpu_work(void)
         flush_scheduled_work();
 }
 
-static inline int
-add_sample(struct oprofile_cpu_buffer *cpu_buf,
-           unsigned long pc, unsigned long event)
+/*
+ * This function prepares the cpu buffer to write a sample.
+ *
+ * Struct op_entry is used during operations on the ring buffer while
+ * struct op_sample contains the data that is stored in the ring
+ * buffer. Struct entry can be uninitialized. The function reserves a
+ * data array that is specified by size. Use
+ * op_cpu_buffer_write_commit() after preparing the sample. In case of
+ * errors a null pointer is returned, otherwise the pointer to the
+ * sample.
+ *
+ */
+struct op_sample
+*op_cpu_buffer_write_reserve(struct op_entry *entry, unsigned long size)
+{
+        entry->event = ring_buffer_lock_reserve
+                (op_ring_buffer_write, sizeof(struct op_sample) +
+                 size * sizeof(entry->sample->data[0]), &entry->irq_flags);
+        if (entry->event)
+                entry->sample = ring_buffer_event_data(entry->event);
+        else
+                entry->sample = NULL;
+
+        if (!entry->sample)
+                return NULL;
+
+        entry->size = size;
+        entry->data = entry->sample->data;
+
+        return entry->sample;
+}
+
+int op_cpu_buffer_write_commit(struct op_entry *entry)
+{
+        return ring_buffer_unlock_commit(op_ring_buffer_write, entry->event,
+                                         entry->irq_flags);
+}
+
+struct op_sample *op_cpu_buffer_read_entry(struct op_entry *entry, int cpu)
+{
+        struct ring_buffer_event *e;
+        e = ring_buffer_consume(op_ring_buffer_read, cpu, NULL);
+        if (e)
+                goto event;
+        if (ring_buffer_swap_cpu(op_ring_buffer_read,
+                                 op_ring_buffer_write,
+                                 cpu))
+                return NULL;
+        e = ring_buffer_consume(op_ring_buffer_read, cpu, NULL);
+        if (e)
+                goto event;
+        return NULL;
+
+event:
+        entry->event = e;
+        entry->sample = ring_buffer_event_data(e);
+        entry->size = (ring_buffer_event_length(e) - sizeof(struct op_sample))
+                / sizeof(entry->sample->data[0]);
+        entry->data = entry->sample->data;
+        return entry->sample;
+}
+
+unsigned long op_cpu_buffer_entries(int cpu)
+{
+        return ring_buffer_entries_cpu(op_ring_buffer_read, cpu)
+                + ring_buffer_entries_cpu(op_ring_buffer_write, cpu);
+}
+
+static int
+op_add_code(struct oprofile_cpu_buffer *cpu_buf, unsigned long backtrace,
+            int is_kernel, struct task_struct *task)
 {
         struct op_entry entry;
-        int ret;
+        struct op_sample *sample;
+        unsigned long flags;
+        int size;
+
+        flags = 0;
+
+        if (backtrace)
+                flags |= TRACE_BEGIN;
+
+        /* notice a switch from user->kernel or vice versa */
+        is_kernel = !!is_kernel;
+        if (cpu_buf->last_is_kernel != is_kernel) {
+                cpu_buf->last_is_kernel = is_kernel;
+                flags |= KERNEL_CTX_SWITCH;
+                if (is_kernel)
+                        flags |= IS_KERNEL;
+        }
+
+        /* notice a task switch */
+        if (cpu_buf->last_task != task) {
+                cpu_buf->last_task = task;
+                flags |= USER_CTX_SWITCH;
+        }
+
+        if (!flags)
+                /* nothing to do */
+                return 0;
+
+        if (flags & USER_CTX_SWITCH)
+                size = 1;
+        else
+                size = 0;
+
+        sample = op_cpu_buffer_write_reserve(&entry, size);
+        if (!sample)
+                return -ENOMEM;
 
-        ret = cpu_buffer_write_entry(&entry);
-        if (ret)
-                return ret;
+        sample->eip = ESCAPE_CODE;
+        sample->event = flags;
 
-        entry.sample->eip = pc;
-        entry.sample->event = event;
+        if (size)
+                op_cpu_buffer_add_data(&entry, (unsigned long)task);
 
-        ret = cpu_buffer_write_commit(&entry);
-        if (ret)
-                return ret;
+        op_cpu_buffer_write_commit(&entry);
 
         return 0;
 }
 
 static inline int
-add_code(struct oprofile_cpu_buffer *buffer, unsigned long value)
+op_add_sample(struct oprofile_cpu_buffer *cpu_buf,
+              unsigned long pc, unsigned long event)
 {
-        return add_sample(buffer, ESCAPE_CODE, value);
+        struct op_entry entry;
+        struct op_sample *sample;
+
+        sample = op_cpu_buffer_write_reserve(&entry, 0);
+        if (!sample)
+                return -ENOMEM;
+
+        sample->eip = pc;
+        sample->event = event;
+
+        return op_cpu_buffer_write_commit(&entry);
 }
 
-/* This must be safe from any context. It's safe writing here
- * because of the head/tail separation of the writer and reader
- * of the CPU buffer.
+/*
+ * This must be safe from any context.
  *
  * is_kernel is needed because on some architectures you cannot
  * tell if you are in kernel or user space simply by looking at
  * pc. We tag this in the buffer by generating kernel enter/exit
  * events whenever is_kernel changes
  */
-static int log_sample(struct oprofile_cpu_buffer *cpu_buf, unsigned long pc,
-                      int is_kernel, unsigned long event)
+static int
+log_sample(struct oprofile_cpu_buffer *cpu_buf, unsigned long pc,
+           unsigned long backtrace, int is_kernel, unsigned long event)
 {
-        struct task_struct *task;
-
         cpu_buf->sample_received++;
 
         if (pc == ESCAPE_CODE) {
@@ -193,25 +301,10 @@ static int log_sample(struct oprofile_cpu_buffer *cpu_buf, unsigned long pc,
                 return 0;
         }
 
-        is_kernel = !!is_kernel;
-
-        task = current;
-
-        /* notice a switch from user->kernel or vice versa */
-        if (cpu_buf->last_is_kernel != is_kernel) {
-                cpu_buf->last_is_kernel = is_kernel;
-                if (add_code(cpu_buf, is_kernel))
-                        goto fail;
-        }
-
-        /* notice a task switch */
-        if (cpu_buf->last_task != task) {
-                cpu_buf->last_task = task;
-                if (add_code(cpu_buf, (unsigned long)task))
-                        goto fail;
-        }
+        if (op_add_code(cpu_buf, backtrace, is_kernel, current))
+                goto fail;
 
-        if (add_sample(cpu_buf, pc, event))
+        if (op_add_sample(cpu_buf, pc, event))
                 goto fail;
 
         return 1;
@@ -221,109 +314,102 @@ fail:
         return 0;
 }
 
-static int oprofile_begin_trace(struct oprofile_cpu_buffer *cpu_buf)
+static inline void oprofile_begin_trace(struct oprofile_cpu_buffer *cpu_buf)
 {
-        add_code(cpu_buf, CPU_TRACE_BEGIN);
         cpu_buf->tracing = 1;
-        return 1;
 }
 
-static void oprofile_end_trace(struct oprofile_cpu_buffer *cpu_buf)
+static inline void oprofile_end_trace(struct oprofile_cpu_buffer *cpu_buf)
 {
         cpu_buf->tracing = 0;
 }
 
-void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
-                                unsigned long event, int is_kernel)
+static inline void
+__oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
+                          unsigned long event, int is_kernel)
 {
         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
-
-        if (!backtrace_depth) {
-                log_sample(cpu_buf, pc, is_kernel, event);
-                return;
-        }
-
-        if (!oprofile_begin_trace(cpu_buf))
-                return;
+        unsigned long backtrace = oprofile_backtrace_depth;
 
         /*
          * if log_sample() fail we can't backtrace since we lost the
          * source of this event
          */
-        if (log_sample(cpu_buf, pc, is_kernel, event))
-                oprofile_ops.backtrace(regs, backtrace_depth);
+        if (!log_sample(cpu_buf, pc, backtrace, is_kernel, event))
+                /* failed */
+                return;
+
+        if (!backtrace)
+                return;
+
+        oprofile_begin_trace(cpu_buf);
+        oprofile_ops.backtrace(regs, backtrace);
         oprofile_end_trace(cpu_buf);
 }
 
+void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
+                             unsigned long event, int is_kernel)
+{
+        __oprofile_add_ext_sample(pc, regs, event, is_kernel);
+}
+
 void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
 {
         int is_kernel = !user_mode(regs);
         unsigned long pc = profile_pc(regs);
 
-        oprofile_add_ext_sample(pc, regs, event, is_kernel);
+        __oprofile_add_ext_sample(pc, regs, event, is_kernel);
 }
 
-#ifdef CONFIG_OPROFILE_IBS
-
-#define MAX_IBS_SAMPLE_SIZE 14
-
-void oprofile_add_ibs_sample(struct pt_regs * const regs,
-                             unsigned int * const ibs_sample, int ibs_code)
+/*
+ * Add samples with data to the ring buffer.
+ *
+ * Use oprofile_add_data(&entry, val) to add data and
+ * oprofile_write_commit(&entry) to commit the sample.
+ */
+void
+oprofile_write_reserve(struct op_entry *entry, struct pt_regs * const regs,
+                       unsigned long pc, int code, int size)
 {
+        struct op_sample *sample;
         int is_kernel = !user_mode(regs);
         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
-        struct task_struct *task;
-        int fail = 0;
 
         cpu_buf->sample_received++;
 
-        /* notice a switch from user->kernel or vice versa */
-        if (cpu_buf->last_is_kernel != is_kernel) {
-                if (add_code(cpu_buf, is_kernel))
-                        goto fail;
-                cpu_buf->last_is_kernel = is_kernel;
-        }
-
-        /* notice a task switch */
-        if (!is_kernel) {
-                task = current;
-                if (cpu_buf->last_task != task) {
-                        if (add_code(cpu_buf, (unsigned long)task))
-                                goto fail;
-                        cpu_buf->last_task = task;
-                }
-        }
-
-        fail = fail || add_code(cpu_buf, ibs_code);
-        fail = fail || add_sample(cpu_buf, ibs_sample[0], ibs_sample[1]);
-        fail = fail || add_sample(cpu_buf, ibs_sample[2], ibs_sample[3]);
-        fail = fail || add_sample(cpu_buf, ibs_sample[4], ibs_sample[5]);
-
-        if (ibs_code == IBS_OP_BEGIN) {
-                fail = fail || add_sample(cpu_buf, ibs_sample[6], ibs_sample[7]);
-                fail = fail || add_sample(cpu_buf, ibs_sample[8], ibs_sample[9]);
-                fail = fail || add_sample(cpu_buf, ibs_sample[10], ibs_sample[11]);
-        }
+        /* no backtraces for samples with data */
+        if (op_add_code(cpu_buf, 0, is_kernel, current))
+                goto fail;
 
-        if (fail)
+        sample = op_cpu_buffer_write_reserve(entry, size + 2);
+        if (!sample)
                 goto fail;
+        sample->eip = ESCAPE_CODE;
+        sample->event = 0;              /* no flags */
 
-        if (backtrace_depth)
-                oprofile_ops.backtrace(regs, backtrace_depth);
+        op_cpu_buffer_add_data(entry, code);
+        op_cpu_buffer_add_data(entry, pc);
 
         return;
 
 fail:
         cpu_buf->sample_lost_overflow++;
-        return;
 }
 
-#endif
+int oprofile_add_data(struct op_entry *entry, unsigned long val)
+{
+        return op_cpu_buffer_add_data(entry, val);
+}
+
+int oprofile_write_commit(struct op_entry *entry)
+{
+        return op_cpu_buffer_write_commit(entry);
+}
 
 void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event)
 {
         struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
-        log_sample(cpu_buf, pc, is_kernel, event);
+        log_sample(cpu_buf, pc, 0, is_kernel, event);
 }
 
 void oprofile_add_trace(unsigned long pc)
@@ -340,7 +426,7 @@ void oprofile_add_trace(unsigned long pc)
         if (pc == ESCAPE_CODE)
                 goto fail;
 
-        if (add_sample(cpu_buf, pc, 0))
+        if (op_add_sample(cpu_buf, pc, 0))
                 goto fail;
 
         return;
diff --git a/drivers/oprofile/cpu_buffer.h b/drivers/oprofile/cpu_buffer.h
index aacb0f0bc566..63f81c44846a 100644
--- a/drivers/oprofile/cpu_buffer.h
+++ b/drivers/oprofile/cpu_buffer.h
@@ -1,10 +1,11 @@
 /**
  * @file cpu_buffer.h
  *
- * @remark Copyright 2002 OProfile authors
+ * @remark Copyright 2002-2009 OProfile authors
  * @remark Read the file COPYING
  *
  * @author John Levon <levon@movementarian.org>
+ * @author Robert Richter <robert.richter@amd.com>
  */
 
 #ifndef OPROFILE_CPU_BUFFER_H
@@ -31,17 +32,12 @@ void end_cpu_work(void);
 struct op_sample {
         unsigned long eip;
         unsigned long event;
+        unsigned long data[0];
 };
 
-struct op_entry {
-        struct ring_buffer_event *event;
-        struct op_sample *sample;
-        unsigned long irq_flags;
-};
+struct op_entry;
 
 struct oprofile_cpu_buffer {
-        volatile unsigned long head_pos;
-        volatile unsigned long tail_pos;
         unsigned long buffer_size;
         struct task_struct *last_task;
         int last_is_kernel;
@@ -54,8 +50,6 @@ struct oprofile_cpu_buffer {
         struct delayed_work work;
 };
 
-extern struct ring_buffer *op_ring_buffer_read;
-extern struct ring_buffer *op_ring_buffer_write;
 DECLARE_PER_CPU(struct oprofile_cpu_buffer, cpu_buffer);
 
 /*
@@ -64,7 +58,7 @@ DECLARE_PER_CPU(struct oprofile_cpu_buffer, cpu_buffer);
  * reset these to invalid values; the next sample collected will
  * populate the buffer with proper values to initialize the buffer
  */
-static inline void cpu_buffer_reset(int cpu)
+static inline void op_cpu_buffer_reset(int cpu)
 {
         struct oprofile_cpu_buffer *cpu_buf = &per_cpu(cpu_buffer, cpu);
 
@@ -72,55 +66,48 @@ static inline void cpu_buffer_reset(int cpu)
         cpu_buf->last_task = NULL;
 }
 
-static inline int cpu_buffer_write_entry(struct op_entry *entry)
-{
-        entry->event = ring_buffer_lock_reserve(op_ring_buffer_write,
-                                                sizeof(struct op_sample),
-                                                &entry->irq_flags);
-        if (entry->event)
-                entry->sample = ring_buffer_event_data(entry->event);
-        else
-                entry->sample = NULL;
-
-        if (!entry->sample)
-                return -ENOMEM;
-
-        return 0;
-}
+struct op_sample
+*op_cpu_buffer_write_reserve(struct op_entry *entry, unsigned long size);
+int op_cpu_buffer_write_commit(struct op_entry *entry);
+struct op_sample *op_cpu_buffer_read_entry(struct op_entry *entry, int cpu);
+unsigned long op_cpu_buffer_entries(int cpu);
 
-static inline int cpu_buffer_write_commit(struct op_entry *entry)
+/* returns the remaining free size of data in the entry */
+static inline
+int op_cpu_buffer_add_data(struct op_entry *entry, unsigned long val)
 {
-        return ring_buffer_unlock_commit(op_ring_buffer_write, entry->event,
-                                         entry->irq_flags);
+        if (!entry->size)
+                return 0;
+        *entry->data = val;
+        entry->size--;
+        entry->data++;
+        return entry->size;
 }
 
-static inline struct op_sample *cpu_buffer_read_entry(int cpu)
+/* returns the size of data in the entry */
+static inline
+int op_cpu_buffer_get_size(struct op_entry *entry)
 {
-        struct ring_buffer_event *e;
-        e = ring_buffer_consume(op_ring_buffer_read, cpu, NULL);
-        if (e)
-                return ring_buffer_event_data(e);
-        if (ring_buffer_swap_cpu(op_ring_buffer_read,
-                                 op_ring_buffer_write,
-                                 cpu))
-                return NULL;
-        e = ring_buffer_consume(op_ring_buffer_read, cpu, NULL);
-        if (e)
-                return ring_buffer_event_data(e);
-        return NULL;
+        return entry->size;
 }
 
-/* "acquire" as many cpu buffer slots as we can */
-static inline unsigned long cpu_buffer_entries(int cpu)
+/* returns 0 if empty or the size of data including the current value */
+static inline
+int op_cpu_buffer_get_data(struct op_entry *entry, unsigned long *val)
 {
-        return ring_buffer_entries_cpu(op_ring_buffer_read, cpu)
-                + ring_buffer_entries_cpu(op_ring_buffer_write, cpu);
+        int size = entry->size;
+        if (!size)
+                return 0;
+        *val = *entry->data;
+        entry->size--;
+        entry->data++;
+        return size;
 }
 
-/* transient events for the CPU buffer -> event buffer */
-#define CPU_IS_KERNEL 1
-#define CPU_TRACE_BEGIN 2
-#define IBS_FETCH_BEGIN 3
-#define IBS_OP_BEGIN    4
+/* extra data flags */
+#define KERNEL_CTX_SWITCH       (1UL << 0)
+#define IS_KERNEL               (1UL << 1)
+#define TRACE_BEGIN             (1UL << 2)
+#define USER_CTX_SWITCH         (1UL << 3)
 
 #endif /* OPROFILE_CPU_BUFFER_H */
diff --git a/drivers/oprofile/event_buffer.c b/drivers/oprofile/event_buffer.c
index 191a3202cecc..2b7ae366ceb1 100644
--- a/drivers/oprofile/event_buffer.c
+++ b/drivers/oprofile/event_buffer.c
@@ -73,8 +73,8 @@ int alloc_event_buffer(void)
         unsigned long flags;
 
         spin_lock_irqsave(&oprofilefs_lock, flags);
-        buffer_size = fs_buffer_size;
-        buffer_watershed = fs_buffer_watershed;
+        buffer_size = oprofile_buffer_size;
+        buffer_watershed = oprofile_buffer_watershed;
         spin_unlock_irqrestore(&oprofilefs_lock, flags);
 
         if (buffer_watershed >= buffer_size)
diff --git a/drivers/oprofile/oprof.c b/drivers/oprofile/oprof.c
index cd375907f26f..3cffce90f82a 100644
--- a/drivers/oprofile/oprof.c
+++ b/drivers/oprofile/oprof.c
@@ -23,7 +23,7 @@
 struct oprofile_operations oprofile_ops;
 
 unsigned long oprofile_started;
-unsigned long backtrace_depth;
+unsigned long oprofile_backtrace_depth;
 static unsigned long is_setup;
 static DEFINE_MUTEX(start_mutex);
 
@@ -172,7 +172,7 @@ int oprofile_set_backtrace(unsigned long val)
                 goto out;
         }
 
-        backtrace_depth = val;
+        oprofile_backtrace_depth = val;
 
 out:
         mutex_unlock(&start_mutex);
diff --git a/drivers/oprofile/oprof.h b/drivers/oprofile/oprof.h
index 5df0c21a608f..c288d3c24b50 100644
--- a/drivers/oprofile/oprof.h
+++ b/drivers/oprofile/oprof.h
@@ -21,12 +21,12 @@ void oprofile_stop(void);
 
 struct oprofile_operations;
 
-extern unsigned long fs_buffer_size;
-extern unsigned long fs_cpu_buffer_size;
-extern unsigned long fs_buffer_watershed;
+extern unsigned long oprofile_buffer_size;
+extern unsigned long oprofile_cpu_buffer_size;
+extern unsigned long oprofile_buffer_watershed;
 extern struct oprofile_operations oprofile_ops;
 extern unsigned long oprofile_started;
-extern unsigned long backtrace_depth;
+extern unsigned long oprofile_backtrace_depth;
 
 struct super_block;
 struct dentry;
diff --git a/drivers/oprofile/oprofile_files.c b/drivers/oprofile/oprofile_files.c
index d8201998b0b7..5d36ffc30dd5 100644
--- a/drivers/oprofile/oprofile_files.c
+++ b/drivers/oprofile/oprofile_files.c
@@ -14,17 +14,18 @@
 #include "oprofile_stats.h"
 #include "oprof.h"
 
-#define FS_BUFFER_SIZE_DEFAULT          131072
-#define FS_CPU_BUFFER_SIZE_DEFAULT      8192
-#define FS_BUFFER_WATERSHED_DEFAULT     32768   /* FIXME: tune */
+#define BUFFER_SIZE_DEFAULT             131072
+#define CPU_BUFFER_SIZE_DEFAULT         8192
+#define BUFFER_WATERSHED_DEFAULT        32768   /* FIXME: tune */
 
-unsigned long fs_buffer_size;
-unsigned long fs_cpu_buffer_size;
-unsigned long fs_buffer_watershed;
+unsigned long oprofile_buffer_size;
+unsigned long oprofile_cpu_buffer_size;
+unsigned long oprofile_buffer_watershed;
 
 static ssize_t depth_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 {
-        return oprofilefs_ulong_to_user(backtrace_depth, buf, count, offset);
+        return oprofilefs_ulong_to_user(oprofile_backtrace_depth, buf, count,
+                                        offset);
 }
 
 
@@ -125,16 +126,16 @@ static const struct file_operations dump_fops = {
 void oprofile_create_files(struct super_block *sb, struct dentry *root)
 {
         /* reinitialize default values */
-        fs_buffer_size =        FS_BUFFER_SIZE_DEFAULT;
-        fs_cpu_buffer_size =    FS_CPU_BUFFER_SIZE_DEFAULT;
-        fs_buffer_watershed =   FS_BUFFER_WATERSHED_DEFAULT;
+        oprofile_buffer_size =          BUFFER_SIZE_DEFAULT;
+        oprofile_cpu_buffer_size =      CPU_BUFFER_SIZE_DEFAULT;
+        oprofile_buffer_watershed =     BUFFER_WATERSHED_DEFAULT;
 
         oprofilefs_create_file(sb, root, "enable", &enable_fops);
         oprofilefs_create_file_perm(sb, root, "dump", &dump_fops, 0666);
         oprofilefs_create_file(sb, root, "buffer", &event_buffer_fops);
-        oprofilefs_create_ulong(sb, root, "buffer_size", &fs_buffer_size);
-        oprofilefs_create_ulong(sb, root, "buffer_watershed", &fs_buffer_watershed);
-        oprofilefs_create_ulong(sb, root, "cpu_buffer_size", &fs_cpu_buffer_size);
+        oprofilefs_create_ulong(sb, root, "buffer_size", &oprofile_buffer_size);
+        oprofilefs_create_ulong(sb, root, "buffer_watershed", &oprofile_buffer_watershed);
+        oprofilefs_create_ulong(sb, root, "cpu_buffer_size", &oprofile_cpu_buffer_size);
         oprofilefs_create_file(sb, root, "cpu_type", &cpu_type_fops);
         oprofilefs_create_file(sb, root, "backtrace_depth", &depth_fops);
         oprofilefs_create_file(sb, root, "pointer_size", &pointer_size_fops);
diff --git a/drivers/regulator/wm8350-regulator.c b/drivers/regulator/wm8350-regulator.c
index c68c496b2c49..7aa35248181b 100644
--- a/drivers/regulator/wm8350-regulator.c
+++ b/drivers/regulator/wm8350-regulator.c
@@ -1412,6 +1412,97 @@ int wm8350_register_regulator(struct wm8350 *wm8350, int reg,
 }
 EXPORT_SYMBOL_GPL(wm8350_register_regulator);
 
+/**
+ * wm8350_register_led - Register a WM8350 LED output
+ *
+ * @param wm8350 The WM8350 device to configure.
+ * @param lednum LED device index to create.
+ * @param dcdc The DCDC to use for the LED.
+ * @param isink The ISINK to use for the LED.
+ * @param pdata Configuration for the LED.
+ *
+ * The WM8350 supports the use of an ISINK together with a DCDC to
+ * provide a power-efficient LED driver.  This function registers the
+ * regulators and instantiates the platform device for a LED.  The
+ * operating modes for the LED regulators must be configured using
+ * wm8350_isink_set_flash(), wm8350_dcdc25_set_mode() and
+ * wm8350_dcdc_set_slot() prior to calling this function.
+ */
+int wm8350_register_led(struct wm8350 *wm8350, int lednum, int dcdc, int isink,
+                        struct wm8350_led_platform_data *pdata)
+{
+        struct wm8350_led *led;
+        struct platform_device *pdev;
+        int ret;
+
+        if (lednum > ARRAY_SIZE(wm8350->pmic.led) || lednum < 0) {
+                dev_err(wm8350->dev, "Invalid LED index %d\n", lednum);
+                return -ENODEV;
+        }
+
+        led = &wm8350->pmic.led[lednum];
+
+        if (led->pdev) {
+                dev_err(wm8350->dev, "LED %d already allocated\n", lednum);
+                return -EINVAL;
+        }
+
+        pdev = platform_device_alloc("wm8350-led", lednum);
+        if (pdev == NULL) {
+                dev_err(wm8350->dev, "Failed to allocate LED %d\n", lednum);
+                return -ENOMEM;
+        }
+
+        led->isink_consumer.dev = &pdev->dev;
+        led->isink_consumer.supply = "led_isink";
+        led->isink_init.num_consumer_supplies = 1;
+        led->isink_init.consumer_supplies = &led->isink_consumer;
+        led->isink_init.constraints.min_uA = 0;
+        led->isink_init.constraints.max_uA = pdata->max_uA;
+        led->isink_init.constraints.valid_ops_mask = REGULATOR_CHANGE_CURRENT;
+        led->isink_init.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL;
+        ret = wm8350_register_regulator(wm8350, isink, &led->isink_init);
+        if (ret != 0) {
+                platform_device_put(pdev);
+                return ret;
+        }
+
+        led->dcdc_consumer.dev = &pdev->dev;
+        led->dcdc_consumer.supply = "led_vcc";
+        led->dcdc_init.num_consumer_supplies = 1;
+        led->dcdc_init.consumer_supplies = &led->dcdc_consumer;
+        led->dcdc_init.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL;
+        ret = wm8350_register_regulator(wm8350, dcdc, &led->dcdc_init);
+        if (ret != 0) {
+                platform_device_put(pdev);
+                return ret;
+        }
+
+        switch (isink) {
+        case WM8350_ISINK_A:
+                wm8350->pmic.isink_A_dcdc = dcdc;
+                break;
+        case WM8350_ISINK_B:
+                wm8350->pmic.isink_B_dcdc = dcdc;
+                break;
+        }
+
+        pdev->dev.platform_data = pdata;
+        pdev->dev.parent = wm8350->dev;
+        ret = platform_device_add(pdev);
+        if (ret != 0) {
+                dev_err(wm8350->dev, "Failed to register LED %d: %d\n",
+                        lednum, ret);
+                platform_device_put(pdev);
+                return ret;
+        }
+
+        led->pdev = pdev;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(wm8350_register_led);
+
 static struct platform_driver wm8350_regulator_driver = {
         .probe = wm8350_regulator_probe,
         .remove = wm8350_regulator_remove,
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 570ae59c1d5e..bd5914994142 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -336,6 +336,9 @@ static int
 dasd_state_ready_to_online(struct dasd_device * device)
 {
         int rc;
+        struct gendisk *disk;
+        struct disk_part_iter piter;
+        struct hd_struct *part;
 
         if (device->discipline->ready_to_online) {
                 rc = device->discipline->ready_to_online(device);
@@ -343,8 +346,14 @@ dasd_state_ready_to_online(struct dasd_device * device)
                         return rc;
         }
         device->state = DASD_STATE_ONLINE;
-        if (device->block)
+        if (device->block) {
                 dasd_schedule_block_bh(device->block);
+                disk = device->block->bdev->bd_disk;
+                disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
+                while ((part = disk_part_iter_next(&piter)))
+                        kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE);
+                disk_part_iter_exit(&piter);
+        }
         return 0;
 }
 
@@ -354,6 +363,9 @@ dasd_state_ready_to_online(struct dasd_device * device)
 static int dasd_state_online_to_ready(struct dasd_device *device)
 {
         int rc;
+        struct gendisk *disk;
+        struct disk_part_iter piter;
+        struct hd_struct *part;
 
         if (device->discipline->online_to_ready) {
                 rc = device->discipline->online_to_ready(device);
@@ -361,6 +373,13 @@ static int dasd_state_online_to_ready(struct dasd_device *device)
                         return rc;
         }
         device->state = DASD_STATE_READY;
+        if (device->block) {
+                disk = device->block->bdev->bd_disk;
+                disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
+                while ((part = disk_part_iter_next(&piter)))
+                        kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE);
+                disk_part_iter_exit(&piter);
+        }
         return 0;
 }
 
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index 2ef25731d197..300e28a531f8 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -206,6 +206,8 @@ dasd_feature_list(char *str, char **endp)
                         features |= DASD_FEATURE_USEDIAG;
                 else if (len == 6 && !strncmp(str, "erplog", 6))
                         features |= DASD_FEATURE_ERPLOG;
+                else if (len == 8 && !strncmp(str, "failfast", 8))
+                        features |= DASD_FEATURE_FAILFAST;
                 else {
                         MESSAGE(KERN_WARNING,
                                 "unsupported feature: %*s, "
@@ -667,6 +669,51 @@ dasd_device_from_cdev(struct ccw_device *cdev)
  */
 
 /*
+ * failfast controls the behaviour, if no path is available
+ */
+static ssize_t dasd_ff_show(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct dasd_devmap *devmap;
+        int ff_flag;
+
+        devmap = dasd_find_busid(dev->bus_id);
+        if (!IS_ERR(devmap))
+                ff_flag = (devmap->features & DASD_FEATURE_FAILFAST) != 0;
+        else
+                ff_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_FAILFAST) != 0;
+        return snprintf(buf, PAGE_SIZE, ff_flag ? "1\n" : "0\n");
+}
+
+static ssize_t dasd_ff_store(struct device *dev, struct device_attribute *attr,
+              const char *buf, size_t count)
+{
+        struct dasd_devmap *devmap;
+        int val;
+        char *endp;
+
+        devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
+        if (IS_ERR(devmap))
+                return PTR_ERR(devmap);
+
+        val = simple_strtoul(buf, &endp, 0);
+        if (((endp + 1) < (buf + count)) || (val > 1))
+                return -EINVAL;
+
+        spin_lock(&dasd_devmap_lock);
+        if (val)
+                devmap->features |= DASD_FEATURE_FAILFAST;
+        else
+                devmap->features &= ~DASD_FEATURE_FAILFAST;
+        if (devmap->device)
+                devmap->device->features = devmap->features;
+        spin_unlock(&dasd_devmap_lock);
+        return count;
+}
+
+static DEVICE_ATTR(failfast, 0644, dasd_ff_show, dasd_ff_store);
+
+/*
  * readonly controls the readonly status of a dasd
  */
 static ssize_t
@@ -1020,6 +1067,7 @@ static struct attribute * dasd_attrs[] = {
         &dev_attr_use_diag.attr,
         &dev_attr_eer_enabled.attr,
         &dev_attr_erplog.attr,
+        &dev_attr_failfast.attr,
         NULL,
 };
 
diff --git a/drivers/s390/block/dasd_diag.c b/drivers/s390/block/dasd_diag.c
index 7844461a995b..ef2a56952054 100644
--- a/drivers/s390/block/dasd_diag.c
+++ b/drivers/s390/block/dasd_diag.c
@@ -544,7 +544,8 @@ static struct dasd_ccw_req *dasd_diag_build_cp(struct dasd_device *memdev,
         }
         cqr->retries = DIAG_MAX_RETRIES;
         cqr->buildclk = get_clock();
-        if (blk_noretry_request(req))
+        if (blk_noretry_request(req) ||
+            block->base->features & DASD_FEATURE_FAILFAST)
                 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->startdev = memdev;
         cqr->memdev = memdev;
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index bd2c52e20762..bdb87998f364 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -1700,7 +1700,8 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
                         recid++;
                 }
         }
-        if (blk_noretry_request(req))
+        if (blk_noretry_request(req) ||
+            block->base->features & DASD_FEATURE_FAILFAST)
                 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->startdev = startdev;
         cqr->memdev = startdev;
diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
index 7d442aeff3d1..f1d176021694 100644
--- a/drivers/s390/block/dasd_fba.c
+++ b/drivers/s390/block/dasd_fba.c
@@ -355,7 +355,8 @@ static struct dasd_ccw_req *dasd_fba_build_cp(struct dasd_device * memdev,
                         recid++;
                 }
         }
-        if (blk_noretry_request(req))
+        if (blk_noretry_request(req) ||
+            block->base->features & DASD_FEATURE_FAILFAST)
                 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->startdev = memdev;
         cqr->memdev = memdev;
diff --git a/drivers/s390/char/Kconfig b/drivers/s390/char/Kconfig
index 643033890e34..0769ced52dbd 100644
--- a/drivers/s390/char/Kconfig
+++ b/drivers/s390/char/Kconfig
@@ -100,7 +100,7 @@ comment "S/390 tape interface support"
 
 config S390_TAPE_BLOCK
         bool "Support for tape block devices"
-        depends on S390_TAPE
+        depends on S390_TAPE && BLOCK
         help
           Select this option if you want to access your channel-attached tape
           devices using the block device interface.  This interface is similar
diff --git a/drivers/s390/cio/qdio_debug.c b/drivers/s390/cio/qdio_debug.c
index f8a3b6967f69..da7afb04e71f 100644
--- a/drivers/s390/cio/qdio_debug.c
+++ b/drivers/s390/cio/qdio_debug.c
@@ -169,6 +169,8 @@ static void setup_debugfs_entry(struct qdio_q *q, struct ccw_device *cdev)
                  q->nr);
         debugfs_queues[i] = debugfs_create_file(name, S_IFREG | S_IRUGO | S_IWUSR,
                                                 debugfs_root, q, &debugfs_fops);
+        if (IS_ERR(debugfs_queues[i]))
+                debugfs_queues[i] = NULL;
 }
 
 void qdio_setup_debug_entries(struct qdio_irq *irq_ptr, struct ccw_device *cdev)
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 4a4dd9adc328..72facb9eb7db 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -52,11 +52,11 @@ config LCD_ILI9320
           then say y to include a power driver for it.
 
 config LCD_TDO24M
-        tristate "Toppoly TDO24M LCD Panels support"
+        tristate "Toppoly TDO24M  and TDO35S LCD Panels support"
         depends on LCD_CLASS_DEVICE && SPI_MASTER
         default n
         help
-          If you have a Toppoly TDO24M series LCD panel, say y here to
+          If you have a Toppoly TDO24M/TDO35S series LCD panel, say y here to
           include the support for it.
 
 config LCD_VGG2432A4
@@ -123,17 +123,14 @@ config BACKLIGHT_ATMEL_PWM
           To compile this driver as a module, choose M here: the module will be
           called atmel-pwm-bl.
 
-config BACKLIGHT_CORGI
-        tristate "Generic (aka Sharp Corgi) Backlight Driver (DEPRECATED)"
+config BACKLIGHT_GENERIC
+        tristate "Generic (aka Sharp Corgi) Backlight Driver"
         depends on BACKLIGHT_CLASS_DEVICE
-        default n
+        default y
         help
           Say y to enable the generic platform backlight driver previously
           known as the Corgi backlight driver. If you have a Sharp Zaurus
-          SL-C7xx, SL-Cxx00 or SL-6000x say y. Most users can say n.
-
-          Note: this driver is marked as deprecated, try enable SPI and
-          use the new corgi_lcd driver with integrated backlight control
+          SL-C7xx, SL-Cxx00 or SL-6000x say y.
 
 config BACKLIGHT_LOCOMO
         tristate "Sharp LOCOMO LCD/Backlight Driver"
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 103427de6703..363b3cb2f01b 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -11,7 +11,7 @@ obj-$(CONFIG_LCD_TOSA)		   += tosa_lcd.o
 
 obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o
 obj-$(CONFIG_BACKLIGHT_ATMEL_PWM)    += atmel-pwm-bl.o
-obj-$(CONFIG_BACKLIGHT_CORGI)   += corgi_bl.o
+obj-$(CONFIG_BACKLIGHT_GENERIC) += generic_bl.o
 obj-$(CONFIG_BACKLIGHT_HP680)   += hp680_bl.o
 obj-$(CONFIG_BACKLIGHT_LOCOMO)  += locomolcd.o
 obj-$(CONFIG_BACKLIGHT_OMAP1)   += omap1_bl.o
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 0664fc032235..157057c79ca3 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -40,6 +40,10 @@ static int fb_notifier_callback(struct notifier_block *self,
                 if (!bd->ops->check_fb ||
                     bd->ops->check_fb(evdata->info)) {
                         bd->props.fb_blank = *(int *)evdata->data;
+                        if (bd->props.fb_blank == FB_BLANK_UNBLANK)
+                                bd->props.state &= ~BL_CORE_FBBLANK;
+                        else
+                                bd->props.state |= BL_CORE_FBBLANK;
                         backlight_update_status(bd);
                 }
         mutex_unlock(&bd->ops_lock);
@@ -80,20 +84,18 @@ static ssize_t backlight_show_power(struct device *dev,
 static ssize_t backlight_store_power(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t count)
 {
-        int rc = -ENXIO;
-        char *endp;
+        int rc;
         struct backlight_device *bd = to_backlight_device(dev);
-        int power = simple_strtoul(buf, &endp, 0);
-        size_t size = endp - buf;
+        unsigned long power;
 
-        if (*endp && isspace(*endp))
-                size++;
-        if (size != count)
-                return -EINVAL;
+        rc = strict_strtoul(buf, 0, &power);
+        if (rc)
+                return rc;
 
+        rc = -ENXIO;
         mutex_lock(&bd->ops_lock);
         if (bd->ops) {
-                pr_debug("backlight: set power to %d\n", power);
+                pr_debug("backlight: set power to %lu\n", power);
                 if (bd->props.power != power) {
                         bd->props.power = power;
                         backlight_update_status(bd);
@@ -116,28 +118,25 @@ static ssize_t backlight_show_brightness(struct device *dev,
 static ssize_t backlight_store_brightness(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t count)
 {
-        int rc = -ENXIO;
-        char *endp;
+        int rc;
         struct backlight_device *bd = to_backlight_device(dev);
-        int brightness = simple_strtoul(buf, &endp, 0);
-        size_t size = endp - buf;
+        unsigned long brightness;
+
+        rc = strict_strtoul(buf, 0, &brightness);
+        if (rc)
+                return rc;
 
-        if (*endp && isspace(*endp))
-                size++;
-        if (size != count)
-                return -EINVAL;
+        rc = -ENXIO;
 
         mutex_lock(&bd->ops_lock);
         if (bd->ops) {
                 if (brightness > bd->props.max_brightness)
                         rc = -EINVAL;
                 else {
-                        pr_debug("backlight: set brightness to %d\n",
+                        pr_debug("backlight: set brightness to %lu\n",
                                  brightness);
-                        if (bd->props.brightness != brightness) {
-                                bd->props.brightness = brightness;
-                                backlight_update_status(bd);
-                        }
+                        bd->props.brightness = brightness;
+                        backlight_update_status(bd);
                         rc = count;
                 }
         }
@@ -170,6 +169,34 @@ static ssize_t backlight_show_actual_brightness(struct device *dev,
 
 static struct class *backlight_class;
 
+static int backlight_suspend(struct device *dev, pm_message_t state)
+{
+        struct backlight_device *bd = to_backlight_device(dev);
+
+        if (bd->ops->options & BL_CORE_SUSPENDRESUME) {
+                mutex_lock(&bd->ops_lock);
+                bd->props.state |= BL_CORE_SUSPENDED;
+                backlight_update_status(bd);
+                mutex_unlock(&bd->ops_lock);
+        }
+
+        return 0;
+}
+
+static int backlight_resume(struct device *dev)
+{
+        struct backlight_device *bd = to_backlight_device(dev);
+
+        if (bd->ops->options & BL_CORE_SUSPENDRESUME) {
+                mutex_lock(&bd->ops_lock);
+                bd->props.state &= ~BL_CORE_SUSPENDED;
+                backlight_update_status(bd);
+                mutex_unlock(&bd->ops_lock);
+        }
+
+        return 0;
+}
+
 static void bl_device_release(struct device *dev)
 {
         struct backlight_device *bd = to_backlight_device(dev);
@@ -286,6 +313,8 @@ static int __init backlight_class_init(void)
         }
 
         backlight_class->dev_attrs = bl_device_attributes;
+        backlight_class->suspend = backlight_suspend;
+        backlight_class->resume = backlight_resume;
         return 0;
 }
 
diff --git a/drivers/video/backlight/corgi_bl.c b/drivers/video/backlight/corgi_bl.c
deleted file mode 100644
index 4d4d037e3ec9..000000000000
--- a/drivers/video/backlight/corgi_bl.c
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- *  Backlight Driver for Sharp Zaurus Handhelds (various models)
- *
- *  Copyright (c) 2004-2006 Richard Purdie
- *
- *  Based on Sharp's 2.4 Backlight Driver
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/mutex.h>
-#include <linux/fb.h>
-#include <linux/backlight.h>
-
-static int corgibl_intensity;
-static struct backlight_properties corgibl_data;
-static struct backlight_device *corgi_backlight_device;
-static struct generic_bl_info *bl_machinfo;
-
-static unsigned long corgibl_flags;
-#define CORGIBL_SUSPENDED     0x01
-#define CORGIBL_BATTLOW       0x02
-
-static int corgibl_send_intensity(struct backlight_device *bd)
-{
-        int intensity = bd->props.brightness;
-
-        if (bd->props.power != FB_BLANK_UNBLANK)
-                intensity = 0;
-        if (bd->props.fb_blank != FB_BLANK_UNBLANK)
-                intensity = 0;
-        if (corgibl_flags & CORGIBL_SUSPENDED)
-                intensity = 0;
-        if (corgibl_flags & CORGIBL_BATTLOW)
-                intensity &= bl_machinfo->limit_mask;
-
-        bl_machinfo->set_bl_intensity(intensity);
-
-        corgibl_intensity = intensity;
-
-        if (bl_machinfo->kick_battery)
-                bl_machinfo->kick_battery();
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int corgibl_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        struct backlight_device *bd = platform_get_drvdata(pdev);
-
-        corgibl_flags |= CORGIBL_SUSPENDED;
-        backlight_update_status(bd);
-        return 0;
-}
-
-static int corgibl_resume(struct platform_device *pdev)
-{
-        struct backlight_device *bd = platform_get_drvdata(pdev);
-
-        corgibl_flags &= ~CORGIBL_SUSPENDED;
-        backlight_update_status(bd);
-        return 0;
-}
-#else
-#define corgibl_suspend NULL
-#define corgibl_resume  NULL
-#endif
-
-static int corgibl_get_intensity(struct backlight_device *bd)
-{
-        return corgibl_intensity;
-}
-
-/*
- * Called when the battery is low to limit the backlight intensity.
- * If limit==0 clear any limit, otherwise limit the intensity
- */
-void corgibl_limit_intensity(int limit)
-{
-        if (limit)
-                corgibl_flags |= CORGIBL_BATTLOW;
-        else
-                corgibl_flags &= ~CORGIBL_BATTLOW;
-        backlight_update_status(corgi_backlight_device);
-}
-EXPORT_SYMBOL(corgibl_limit_intensity);
-
-
-static struct backlight_ops corgibl_ops = {
-        .get_brightness = corgibl_get_intensity,
-        .update_status  = corgibl_send_intensity,
-};
-
-static int corgibl_probe(struct platform_device *pdev)
-{
-        struct generic_bl_info *machinfo = pdev->dev.platform_data;
-        const char *name = "generic-bl";
-
-        bl_machinfo = machinfo;
-        if (!machinfo->limit_mask)
-                machinfo->limit_mask = -1;
-
-        if (machinfo->name)
-                name = machinfo->name;
-
-        corgi_backlight_device = backlight_device_register (name,
-                &pdev->dev, NULL, &corgibl_ops);
-        if (IS_ERR (corgi_backlight_device))
-                return PTR_ERR (corgi_backlight_device);
-
-        platform_set_drvdata(pdev, corgi_backlight_device);
-
-        corgi_backlight_device->props.max_brightness = machinfo->max_intensity;
-        corgi_backlight_device->props.power = FB_BLANK_UNBLANK;
-        corgi_backlight_device->props.brightness = machinfo->default_intensity;
-        backlight_update_status(corgi_backlight_device);
-
-        printk("Corgi Backlight Driver Initialized.\n");
-        return 0;
-}
-
-static int corgibl_remove(struct platform_device *pdev)
-{
-        struct backlight_device *bd = platform_get_drvdata(pdev);
-
-        corgibl_data.power = 0;
-        corgibl_data.brightness = 0;
-        backlight_update_status(bd);
-
-        backlight_device_unregister(bd);
-
-        printk("Corgi Backlight Driver Unloaded\n");
-        return 0;
-}
-
-static struct platform_driver corgibl_driver = {
-        .probe          = corgibl_probe,
-        .remove         = corgibl_remove,
-        .suspend        = corgibl_suspend,
-        .resume         = corgibl_resume,
-        .driver         = {
-                .name   = "generic-bl",
-        },
-};
-
-static int __init corgibl_init(void)
-{
-        return platform_driver_register(&corgibl_driver);
-}
-
-static void __exit corgibl_exit(void)
-{
-        platform_driver_unregister(&corgibl_driver);
-}
-
-module_init(corgibl_init);
-module_exit(corgibl_exit);
-
-MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
-MODULE_DESCRIPTION("Corgi Backlight Driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/video/backlight/cr_bllcd.c b/drivers/video/backlight/cr_bllcd.c
index 26add8898605..b9fe62b475c6 100644
--- a/drivers/video/backlight/cr_bllcd.c
+++ b/drivers/video/backlight/cr_bllcd.c
@@ -259,22 +259,18 @@ static int __init cr_backlight_init(void)
 {
         int ret = platform_driver_register(&cr_backlight_driver);
 
-        if (!ret) {
-                crp = platform_device_alloc("cr_backlight", -1);
-                if (!crp)
-                        return -ENOMEM;
+        if (ret)
+                return ret;
 
-                ret = platform_device_add(crp);
-
-                if (ret) {
-                        platform_device_put(crp);
-                        platform_driver_unregister(&cr_backlight_driver);
-                }
+        crp = platform_device_register_simple("cr_backlight", -1, NULL, 0);
+        if (IS_ERR(crp)) {
+                platform_driver_unregister(&cr_backlight_driver);
+                return PTR_ERR(crp);
         }
 
         printk("Carillo Ranch Backlight Driver Initialized.\n");
 
-        return ret;
+        return 0;
 }
 
 static void __exit cr_backlight_exit(void)
diff --git a/drivers/video/backlight/generic_bl.c b/drivers/video/backlight/generic_bl.c
new file mode 100644
index 000000000000..6d27f62fdcd0
--- /dev/null
+++ b/drivers/video/backlight/generic_bl.c
@@ -0,0 +1,147 @@
+/*
+ *  Generic Backlight Driver
+ *
+ *  Copyright (c) 2004-2008 Richard Purdie
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+
+static int genericbl_intensity;
+static struct backlight_device *generic_backlight_device;
+static struct generic_bl_info *bl_machinfo;
+
+/* Flag to signal when the battery is low */
+#define GENERICBL_BATTLOW       BL_CORE_DRIVER1
+
+static int genericbl_send_intensity(struct backlight_device *bd)
+{
+        int intensity = bd->props.brightness;
+
+        if (bd->props.power != FB_BLANK_UNBLANK)
+                intensity = 0;
+        if (bd->props.state & BL_CORE_FBBLANK)
+                intensity = 0;
+        if (bd->props.state & BL_CORE_SUSPENDED)
+                intensity = 0;
+        if (bd->props.state & GENERICBL_BATTLOW)
+                intensity &= bl_machinfo->limit_mask;
+
+        bl_machinfo->set_bl_intensity(intensity);
+
+        genericbl_intensity = intensity;
+
+        if (bl_machinfo->kick_battery)
+                bl_machinfo->kick_battery();
+
+        return 0;
+}
+
+static int genericbl_get_intensity(struct backlight_device *bd)
+{
+        return genericbl_intensity;
+}
+
+/*
+ * Called when the battery is low to limit the backlight intensity.
+ * If limit==0 clear any limit, otherwise limit the intensity
+ */
+void corgibl_limit_intensity(int limit)
+{
+        struct backlight_device *bd = generic_backlight_device;
+
+        mutex_lock(&bd->ops_lock);
+        if (limit)
+                bd->props.state |= GENERICBL_BATTLOW;
+        else
+                bd->props.state &= ~GENERICBL_BATTLOW;
+        backlight_update_status(generic_backlight_device);
+        mutex_unlock(&bd->ops_lock);
+}
+EXPORT_SYMBOL(corgibl_limit_intensity);
+
+static struct backlight_ops genericbl_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .get_brightness = genericbl_get_intensity,
+        .update_status  = genericbl_send_intensity,
+};
+
+static int genericbl_probe(struct platform_device *pdev)
+{
+        struct generic_bl_info *machinfo = pdev->dev.platform_data;
+        const char *name = "generic-bl";
+        struct backlight_device *bd;
+
+        bl_machinfo = machinfo;
+        if (!machinfo->limit_mask)
+                machinfo->limit_mask = -1;
+
+        if (machinfo->name)
+                name = machinfo->name;
+
+        bd = backlight_device_register (name,
+                &pdev->dev, NULL, &genericbl_ops);
+        if (IS_ERR (bd))
+                return PTR_ERR (bd);
+
+        platform_set_drvdata(pdev, bd);
+
+        bd->props.max_brightness = machinfo->max_intensity;
+        bd->props.power = FB_BLANK_UNBLANK;
+        bd->props.brightness = machinfo->default_intensity;
+        backlight_update_status(bd);
+
+        generic_backlight_device = bd;
+
+        printk("Generic Backlight Driver Initialized.\n");
+        return 0;
+}
+
+static int genericbl_remove(struct platform_device *pdev)
+{
+        struct backlight_device *bd = platform_get_drvdata(pdev);
+
+        bd->props.power = 0;
+        bd->props.brightness = 0;
+        backlight_update_status(bd);
+
+        backlight_device_unregister(bd);
+
+        printk("Generic Backlight Driver Unloaded\n");
+        return 0;
+}
+
+static struct platform_driver genericbl_driver = {
+        .probe          = genericbl_probe,
+        .remove         = genericbl_remove,
+        .driver         = {
+                .name   = "generic-bl",
+        },
+};
+
+static int __init genericbl_init(void)
+{
+        return platform_driver_register(&genericbl_driver);
+}
+
+static void __exit genericbl_exit(void)
+{
+        platform_driver_unregister(&genericbl_driver);
+}
+
+module_init(genericbl_init);
+module_exit(genericbl_exit);
+
+MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
+MODULE_DESCRIPTION("Generic Backlight Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/backlight/hp680_bl.c b/drivers/video/backlight/hp680_bl.c
index d4cfed0b26d5..5be55a20d8c7 100644
--- a/drivers/video/backlight/hp680_bl.c
+++ b/drivers/video/backlight/hp680_bl.c
@@ -151,19 +151,15 @@ static int __init hp680bl_init(void)
         int ret;
 
         ret = platform_driver_register(&hp680bl_driver);
-        if (!ret) {
-                hp680bl_device = platform_device_alloc("hp680-bl", -1);
-                if (!hp680bl_device)
-                        return -ENOMEM;
-
-                ret = platform_device_add(hp680bl_device);
-
-                if (ret) {
-                        platform_device_put(hp680bl_device);
-                        platform_driver_unregister(&hp680bl_driver);
-                }
+        if (ret)
+                return ret;
+        hp680bl_device = platform_device_register_simple("hp680-bl", -1,
+                                                        NULL, 0);
+        if (IS_ERR(hp680bl_device)) {
+                platform_driver_unregister(&hp680bl_driver);
+                return PTR_ERR(hp680bl_device);
         }
-        return ret;
+        return 0;
 }
 
 static void __exit hp680bl_exit(void)
diff --git a/drivers/video/backlight/mbp_nvidia_bl.c b/drivers/video/backlight/mbp_nvidia_bl.c
index 06964af761c6..65864c500455 100644
--- a/drivers/video/backlight/mbp_nvidia_bl.c
+++ b/drivers/video/backlight/mbp_nvidia_bl.c
@@ -70,6 +70,7 @@ static int mbp_get_intensity(struct backlight_device *bd)
 }
 
 static struct backlight_ops mbp_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
         .get_brightness = mbp_get_intensity,
         .update_status  = mbp_send_intensity,
 };
diff --git a/drivers/video/backlight/progear_bl.c b/drivers/video/backlight/progear_bl.c
index 15fb4d58b5bc..9edaf24fd82d 100644
--- a/drivers/video/backlight/progear_bl.c
+++ b/drivers/video/backlight/progear_bl.c
@@ -119,20 +119,16 @@ static int __init progearbl_init(void)
 {
         int ret = platform_driver_register(&progearbl_driver);
 
-        if (!ret) {
-                progearbl_device = platform_device_alloc("progear-bl", -1);
-                if (!progearbl_device)
-                        return -ENOMEM;
-
-                ret = platform_device_add(progearbl_device);
-
-                if (ret) {
-                        platform_device_put(progearbl_device);
-                        platform_driver_unregister(&progearbl_driver);
-                }
+        if (ret)
+                return ret;
+        progearbl_device = platform_device_register_simple("progear-bl", -1,
+                                                                NULL, 0);
+        if (IS_ERR(progearbl_device)) {
+                platform_driver_unregister(&progearbl_driver);
+                return PTR_ERR(progearbl_device);
         }
 
-        return ret;
+        return 0;
 }
 
 static void __exit progearbl_exit(void)
diff --git a/drivers/video/backlight/tdo24m.c b/drivers/video/backlight/tdo24m.c
index 8427669162ea..1dae7f8f3c6b 100644
--- a/drivers/video/backlight/tdo24m.c
+++ b/drivers/video/backlight/tdo24m.c
@@ -14,6 +14,7 @@
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/spi/spi.h>
+#include <linux/spi/tdo24m.h>
 #include <linux/fb.h>
 #include <linux/lcd.h>
 
@@ -31,6 +32,9 @@ struct tdo24m {
         struct spi_transfer     xfer;
         uint8_t                 *buf;
 
+        int (*adj_mode)(struct tdo24m *lcd, int mode);
+        int color_invert;
+
         int                     power;
         int                     mode;
 };
@@ -66,7 +70,7 @@ static uint32_t lcd_panel_off[] = {
         CMD_NULL,
 };
 
-static uint32_t lcd_vga_pass_through[] = {
+static uint32_t lcd_vga_pass_through_tdo24m[] = {
         CMD1(0xB0, 0x16),
         CMD1(0xBC, 0x80),
         CMD1(0xE1, 0x00),
@@ -75,7 +79,7 @@ static uint32_t lcd_vga_pass_through[] = {
         CMD_NULL,
 };
 
-static uint32_t lcd_qvga_pass_through[] = {
+static uint32_t lcd_qvga_pass_through_tdo24m[] = {
         CMD1(0xB0, 0x16),
         CMD1(0xBC, 0x81),
         CMD1(0xE1, 0x00),
@@ -84,7 +88,7 @@ static uint32_t lcd_qvga_pass_through[] = {
         CMD_NULL,
 };
 
-static uint32_t lcd_vga_transfer[] = {
+static uint32_t lcd_vga_transfer_tdo24m[] = {
         CMD1(0xcf, 0x02),       /* Blanking period control (1) */
         CMD2(0xd0, 0x08, 0x04), /* Blanking period control (2) */
         CMD1(0xd1, 0x01),       /* CKV timing control on/off */
@@ -110,6 +114,35 @@ static uint32_t lcd_qvga_transfer[] = {
         CMD_NULL,
 };
 
+static uint32_t lcd_vga_pass_through_tdo35s[] = {
+        CMD1(0xB0, 0x16),
+        CMD1(0xBC, 0x80),
+        CMD1(0xE1, 0x00),
+        CMD1(0x3B, 0x00),
+        CMD_NULL,
+};
+
+static uint32_t lcd_qvga_pass_through_tdo35s[] = {
+        CMD1(0xB0, 0x16),
+        CMD1(0xBC, 0x81),
+        CMD1(0xE1, 0x00),
+        CMD1(0x3B, 0x22),
+        CMD_NULL,
+};
+
+static uint32_t lcd_vga_transfer_tdo35s[] = {
+        CMD1(0xcf, 0x02),       /* Blanking period control (1) */
+        CMD2(0xd0, 0x08, 0x04), /* Blanking period control (2) */
+        CMD1(0xd1, 0x01),       /* CKV timing control on/off */
+        CMD2(0xd2, 0x00, 0x1e), /* CKV 1,2 timing control */
+        CMD2(0xd3, 0x14, 0x28), /* OEV timing control */
+        CMD2(0xd4, 0x28, 0x64), /* ASW timing control (1) */
+        CMD1(0xd5, 0x28),       /* ASW timing control (2) */
+        CMD0(0x21),             /* Invert for normally black display */
+        CMD0(0x29),             /* Display on */
+        CMD_NULL,
+};
+
 static uint32_t lcd_panel_config[] = {
         CMD2(0xb8, 0xff, 0xf9), /* Output control */
         CMD0(0x11),             /* sleep out */
@@ -148,6 +181,8 @@ static int tdo24m_writes(struct tdo24m *lcd, uint32_t *array)
         int nparams, err = 0;
 
         for (; *p != CMD_NULL; p++) {
+                if (!lcd->color_invert && *p == CMD0(0x21))
+                        continue;
 
                 nparams = (*p >> 30) & 0x3;
 
@@ -184,12 +219,33 @@ static int tdo24m_adj_mode(struct tdo24m *lcd, int mode)
 {
         switch (mode) {
         case MODE_VGA:
-                tdo24m_writes(lcd, lcd_vga_pass_through);
+                tdo24m_writes(lcd, lcd_vga_pass_through_tdo24m);
                 tdo24m_writes(lcd, lcd_panel_config);
-                tdo24m_writes(lcd, lcd_vga_transfer);
+                tdo24m_writes(lcd, lcd_vga_transfer_tdo24m);
                 break;
         case MODE_QVGA:
-                tdo24m_writes(lcd, lcd_qvga_pass_through);
+                tdo24m_writes(lcd, lcd_qvga_pass_through_tdo24m);
+                tdo24m_writes(lcd, lcd_panel_config);
+                tdo24m_writes(lcd, lcd_qvga_transfer);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        lcd->mode = mode;
+        return 0;
+}
+
+static int tdo35s_adj_mode(struct tdo24m *lcd, int mode)
+{
+        switch (mode) {
+        case MODE_VGA:
+                tdo24m_writes(lcd, lcd_vga_pass_through_tdo35s);
+                tdo24m_writes(lcd, lcd_panel_config);
+                tdo24m_writes(lcd, lcd_vga_transfer_tdo35s);
+                break;
+        case MODE_QVGA:
+                tdo24m_writes(lcd, lcd_qvga_pass_through_tdo35s);
                 tdo24m_writes(lcd, lcd_panel_config);
                 tdo24m_writes(lcd, lcd_qvga_transfer);
                 break;
@@ -213,7 +269,7 @@ static int tdo24m_power_on(struct tdo24m *lcd)
         if (err)
                 goto out;
 
-        err = tdo24m_adj_mode(lcd, lcd->mode);
+        err = lcd->adj_mode(lcd, lcd->mode);
 out:
         return err;
 }
@@ -262,7 +318,7 @@ static int tdo24m_set_mode(struct lcd_device *ld, struct fb_videomode *m)
         if (lcd->mode == mode)
                 return 0;
 
-        return tdo24m_adj_mode(lcd, mode);
+        return lcd->adj_mode(lcd, mode);
 }
 
 static struct lcd_ops tdo24m_ops = {
@@ -276,8 +332,16 @@ static int __devinit tdo24m_probe(struct spi_device *spi)
         struct tdo24m *lcd;
         struct spi_message *m;
         struct spi_transfer *x;
+        struct tdo24m_platform_data *pdata;
+        enum tdo24m_model model;
         int err;
 
+        pdata = spi->dev.platform_data;
+        if (pdata)
+                model = pdata->model;
+        else
+                model = TDO24M;
+
         spi->bits_per_word = 8;
         spi->mode = SPI_MODE_3;
         err = spi_setup(spi);
@@ -306,6 +370,20 @@ static int __devinit tdo24m_probe(struct spi_device *spi)
         x->tx_buf = &lcd->buf[0];
         spi_message_add_tail(x, m);
 
+        switch (model) {
+        case TDO24M:
+                lcd->color_invert = 1;
+                lcd->adj_mode = tdo24m_adj_mode;
+                break;
+        case TDO35S:
+                lcd->adj_mode = tdo35s_adj_mode;
+                lcd->color_invert = 0;
+                break;
+        default:
+                dev_err(&spi->dev, "Unsupported model");
+                goto out_free;
+        }
+
         lcd->lcd_dev = lcd_device_register("tdo24m", &spi->dev,
                                         lcd, &tdo24m_ops);
         if (IS_ERR(lcd->lcd_dev)) {
diff --git a/drivers/video/backlight/tosa_lcd.c b/drivers/video/backlight/tosa_lcd.c
index 57a26649f1a5..b7fbc75a62fc 100644
--- a/drivers/video/backlight/tosa_lcd.c
+++ b/drivers/video/backlight/tosa_lcd.c
@@ -39,6 +39,7 @@ struct tosa_lcd_data {
         struct i2c_client *i2c;
 
         int lcd_power;
+        bool is_vga;
 };
 
 static int tosa_tg_send(struct spi_device *spi, int adrs, uint8_t data)
@@ -81,8 +82,12 @@ static void tosa_lcd_tg_init(struct tosa_lcd_data *data)
 static void tosa_lcd_tg_on(struct tosa_lcd_data *data)
 {
         struct spi_device *spi = data->spi;
-        const int value = TG_REG0_COLOR | TG_REG0_UD | TG_REG0_LR;
-        tosa_tg_send(spi, TG_PNLCTL, value | TG_REG0_VQV); /* this depends on mode */
+        int value = TG_REG0_COLOR | TG_REG0_UD | TG_REG0_LR;
+
+        if (data->is_vga)
+                value |= TG_REG0_VQV;
+
+        tosa_tg_send(spi, TG_PNLCTL, value);
 
         /* TG LCD pannel power up */
         tosa_tg_send(spi, TG_PINICTL,0x4);
@@ -142,9 +147,25 @@ static int tosa_lcd_get_power(struct lcd_device *lcd)
         return data->lcd_power;
 }
 
+static int tosa_lcd_set_mode(struct lcd_device *lcd, struct fb_videomode *mode)
+{
+        struct tosa_lcd_data *data = lcd_get_data(lcd);
+
+        if (mode->xres == 320 || mode->yres == 320)
+                data->is_vga = false;
+        else
+                data->is_vga = true;
+
+        if (POWER_IS_ON(data->lcd_power))
+                tosa_lcd_tg_on(data);
+
+        return 0;
+}
+
 static struct lcd_ops tosa_lcd_ops = {
         .set_power = tosa_lcd_set_power,
         .get_power = tosa_lcd_get_power,
+        .set_mode = tosa_lcd_set_mode,
 };
 
 static int __devinit tosa_lcd_probe(struct spi_device *spi)
@@ -156,6 +177,8 @@ static int __devinit tosa_lcd_probe(struct spi_device *spi)
         if (!data)
                 return -ENOMEM;
 
+        data->is_vga = true; /* defaut to VGA mode */
+
         /*
          * bits_per_word cannot be configured in platform data
          */
diff --git a/drivers/video/backlight/vgg2432a4.c b/drivers/video/backlight/vgg2432a4.c
index 593c7687d54a..8e653b8a6f17 100644
--- a/drivers/video/backlight/vgg2432a4.c
+++ b/drivers/video/backlight/vgg2432a4.c
@@ -137,7 +137,7 @@ static int vgg2432a4_lcd_init(struct ili9320 *lcd,
 
         ili9320_write(lcd, ILI9320_RGB_IF1, cfg->rgb_if1);
         ili9320_write(lcd, ILI9320_FRAMEMAKER, 0x0);
-        ili9320_write(lcd, ILI9320_RGB_IF2, ILI9320_RGBIF2_DPL);
+        ili9320_write(lcd, ILI9320_RGB_IF2, cfg->rgb_if2);
 
         ret = ili9320_write_regs(lcd, vgg_init1, ARRAY_SIZE(vgg_init1));
         if (ret != 0)