Merge commit 'v2.6.29-rc1' into irq/urgent

10 files changed, 303 insertions, 185 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 35914b6e1d2a..f5be8081cd81 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -616,6 +616,7 @@ config HVC_ISERIES
         default y
         select HVC_DRIVER
         select HVC_IRQ
+        select VIOPATH
         help
           iSeries machines support a hypervisor virtual console.
 
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 39ad820b2350..af7c13ca9493 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -769,7 +769,7 @@ static int pc_open(struct tty_struct *tty, struct file *filp)
         /* Check status of board configured in system.  */
 
         /*
-         * I check to see if the epca_setup routine detected an user error. It
+         * I check to see if the epca_setup routine detected a user error. It
          * might be better to put this in pc_init, but for the moment it goes
          * here.
          */
diff --git a/drivers/char/hvc_beat.c b/drivers/char/hvc_beat.c
index 91cdb35a9204..0afc8b82212e 100644
--- a/drivers/char/hvc_beat.c
+++ b/drivers/char/hvc_beat.c
@@ -44,7 +44,7 @@ static int hvc_beat_get_chars(uint32_t vtermno, char *buf, int cnt)
         static unsigned char q[sizeof(unsigned long) * 2]
                 __attribute__((aligned(sizeof(unsigned long))));
         static int qlen = 0;
-        unsigned long got;
+        u64 got;
 
 again:
         if (qlen) {
@@ -63,7 +63,7 @@ again:
                 }
         }
         if (beat_get_term_char(vtermno, &got,
-                ((unsigned long *)q), ((unsigned long *)q) + 1) == 0) {
+                ((u64 *)q), ((u64 *)q) + 1) == 0) {
                 qlen = got;
                 goto again;
         }
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/char/hw_random/n2-drv.c b/drivers/char/hw_random/n2-drv.c
index 8859aeac2d25..9b3e09cd41f9 100644
--- a/drivers/char/hw_random/n2-drv.c
+++ b/drivers/char/hw_random/n2-drv.c
@@ -482,7 +482,7 @@ static void n2rng_dump_test_buffer(struct n2rng *np)
         int i;
 
         for (i = 0; i < SELFTEST_BUFFER_WORDS; i++)
-                dev_err(&np->op->dev, "Test buffer slot %d [0x%016lx]\n",
+                dev_err(&np->op->dev, "Test buffer slot %d [0x%016llx]\n",
                         i, np->test_buffer[i]);
 }
 
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index 112a6ba9a96f..146c97613da0 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -32,7 +32,7 @@
 
 /* These are global because they are accessed in tty_io.c */
 #ifdef CONFIG_UNIX98_PTYS
-struct tty_driver *ptm_driver;
+static struct tty_driver *ptm_driver;
 static struct tty_driver *pts_driver;
 #endif
 
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index 20d6efb6324e..e0d0f8b2696b 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -48,9 +48,10 @@
  *              CONFIG_HPET_EMULATE_RTC
  *      1.12a   Maciej W. Rozycki: Handle memory-mapped chips properly.
  *      1.12ac  Alan Cox: Allow read access to the day of week register
+ *      1.12b   David John: Remove calls to the BKL.
  */
 
-#define RTC_VERSION             "1.12ac"
+#define RTC_VERSION             "1.12b"
 
 /*
  *      Note that *all* calls to CMOS_READ and CMOS_WRITE are done with
@@ -73,7 +74,6 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/sysctl.h>
 #include <linux/wait.h>
 #include <linux/bcd.h>
@@ -182,8 +182,8 @@ static int rtc_proc_open(struct inode *inode, struct file *file);
 
 /*
  * rtc_status is never changed by rtc_interrupt, and ioctl/open/close is
- * protected by the big kernel lock. However, ioctl can still disable the timer
- * in rtc_status and then with del_timer after the interrupt has read
+ * protected by the spin lock rtc_lock. However, ioctl can still disable the
+ * timer in rtc_status and then with del_timer after the interrupt has read
  * rtc_status but before mod_timer is called, which would then reenable the
  * timer (but you would need to have an awful timing before you'd trip on it)
  */
@@ -720,9 +720,7 @@ static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
 static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         long ret;
-        lock_kernel();
         ret = rtc_do_ioctl(cmd, arg, 0);
-        unlock_kernel();
         return ret;
 }
 
@@ -731,12 +729,8 @@ static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  *      Also clear the previous interrupt data on an open, and clean
  *      up things on a close.
  */
-
-/* We use rtc_lock to protect against concurrent opens. So the BKL is not
- * needed here. Or anywhere else in this driver. */
 static int rtc_open(struct inode *inode, struct file *file)
 {
-        lock_kernel();
         spin_lock_irq(&rtc_lock);
 
         if (rtc_status & RTC_IS_OPEN)
@@ -746,12 +740,10 @@ static int rtc_open(struct inode *inode, struct file *file)
 
         rtc_irq_data = 0;
         spin_unlock_irq(&rtc_lock);
-        unlock_kernel();
         return 0;
 
 out_busy:
         spin_unlock_irq(&rtc_lock);
-        unlock_kernel();
         return -EBUSY;
 }
 
@@ -800,7 +792,6 @@ no_irq:
 }
 
 #ifdef RTC_IRQ
-/* Called without the kernel lock - fine */
 static unsigned int rtc_poll(struct file *file, poll_table *wait)
 {
         unsigned long l;
diff --git a/drivers/char/tpm/tpm_bios.c b/drivers/char/tpm/tpm_bios.c
index 68f052b42ed7..ed306eb1057f 100644
--- a/drivers/char/tpm/tpm_bios.c
+++ b/drivers/char/tpm/tpm_bios.c
@@ -23,8 +23,6 @@
 #include <linux/security.h>
 #include <linux/module.h>
 #include <acpi/acpi.h>
-#include <acpi/actypes.h>
-#include <acpi/actbl.h>
 #include "tpm.h"
 
 #define TCG_EVENT_NAME_LEN_MAX  255
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index ab18c1e7b115..70efba2ee053 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -273,12 +273,23 @@ static void tpm_nsc_remove(struct device *dev)
         }
 }
 
-static struct device_driver nsc_drv = {
-        .name = "tpm_nsc",
-        .bus = &platform_bus_type,
-        .owner = THIS_MODULE,
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
+static int tpm_nsc_suspend(struct platform_device *dev, pm_message_t msg)
+{
+        return tpm_pm_suspend(&dev->dev, msg);
+}
+
+static int tpm_nsc_resume(struct platform_device *dev)
+{
+        return tpm_pm_resume(&dev->dev);
+}
+
+static struct platform_driver nsc_drv = {
+        .suspend         = tpm_nsc_suspend,
+        .resume          = tpm_nsc_resume,
+        .driver          = {
+                .name    = "tpm_nsc",
+                .owner   = THIS_MODULE,
+        },
 };
 
 static int __init init_nsc(void)
@@ -297,7 +308,7 @@ static int __init init_nsc(void)
                         return -ENODEV;
         }
 
-        err = driver_register(&nsc_drv);
+        err = platform_driver_register(&nsc_drv);
         if (err)
                 return err;
 
@@ -308,17 +319,15 @@ static int __init init_nsc(void)
         /* enable the DPM module */
         tpm_write_index(nscAddrBase, NSC_LDC_INDEX, 0x01);
 
-        pdev = kzalloc(sizeof(struct platform_device), GFP_KERNEL);
+        pdev = platform_device_alloc("tpm_nscl0", -1);
         if (!pdev) {
                 rc = -ENOMEM;
                 goto err_unreg_drv;
         }
 
-        pdev->name = "tpm_nscl0";
-        pdev->id = -1;
         pdev->num_resources = 0;
+        pdev->dev.driver = &nsc_drv.driver;
         pdev->dev.release = tpm_nsc_remove;
-        pdev->dev.driver = &nsc_drv;
 
         if ((rc = platform_device_register(pdev)) < 0)
                 goto err_free_dev;
@@ -377,7 +386,7 @@ err_unreg_dev:
 err_free_dev:
         kfree(pdev);
 err_unreg_drv:
-        driver_unregister(&nsc_drv);
+        platform_driver_unregister(&nsc_drv);
         return rc;
 }
 
@@ -390,7 +399,7 @@ static void __exit cleanup_nsc(void)
                 pdev = NULL;
         }
 
-        driver_unregister(&nsc_drv);
+        platform_driver_unregister(&nsc_drv);
 }
 
 module_init(init_nsc);
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 80014213fb53..7900bd63b36d 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -969,8 +969,7 @@ int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int rows)
  *      Takes the console sem and the called methods then take the tty
  *      termios_mutex and the tty ctrl_lock in that order.
  */
-
-int vt_resize(struct tty_struct *tty, struct winsize *ws)
+static int vt_resize(struct tty_struct *tty, struct winsize *ws)
 {
         struct vc_data *vc = tty->driver_data;
         int ret;