Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 1195 insertions, 0 deletions

diff --git a/drivers/char/viocons.c b/drivers/char/viocons.c
new file mode 100644
index 000000000000..44f5fb4a46ef
--- /dev/null
+++ b/drivers/char/viocons.c
@@ -0,0 +1,1195 @@
+/* -*- linux-c -*-
+ *
+ *  drivers/char/viocons.c
+ *
+ *  iSeries Virtual Terminal
+ *
+ *  Authors: Dave Boutcher <boutcher@us.ibm.com>
+ *           Ryan Arnold <ryanarn@us.ibm.com>
+ *           Colin Devilbiss <devilbis@us.ibm.com>
+ *           Stephen Rothwell <sfr@au1.ibm.com>
+ *
+ * (C) Copyright 2000, 2001, 2002, 2003, 2004 IBM Corporation
+ *
+ * This program is free software;  you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) anyu later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/errno.h>
+#include <linux/vmalloc.h>
+#include <linux/mm.h>
+#include <linux/console.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+#include <linux/init.h>
+#include <linux/wait.h>
+#include <linux/spinlock.h>
+#include <asm/ioctls.h>
+#include <linux/kd.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/sysrq.h>
+
+#include <asm/iSeries/vio.h>
+
+#include <asm/iSeries/HvLpEvent.h>
+#include <asm/iSeries/HvCallEvent.h>
+#include <asm/iSeries/HvLpConfig.h>
+#include <asm/iSeries/HvCall.h>
+
+#ifdef CONFIG_VT
+#error You must turn off CONFIG_VT to use CONFIG_VIOCONS
+#endif
+
+#define VIOTTY_MAGIC (0x0DCB)
+#define VTTY_PORTS 10
+
+#define VIOCONS_KERN_WARN       KERN_WARNING "viocons: "
+#define VIOCONS_KERN_INFO       KERN_INFO "viocons: "
+
+static DEFINE_SPINLOCK(consolelock);
+static DEFINE_SPINLOCK(consoleloglock);
+
+#ifdef CONFIG_MAGIC_SYSRQ
+static int vio_sysrq_pressed;
+extern int sysrq_enabled;
+#endif
+
+/*
+ * The structure of the events that flow between us and OS/400.  You can't
+ * mess with this unless the OS/400 side changes too
+ */
+struct viocharlpevent {
+        struct HvLpEvent event;
+        u32 reserved;
+        u16 version;
+        u16 subtype_result_code;
+        u8 virtual_device;
+        u8 len;
+        u8 data[VIOCHAR_MAX_DATA];
+};
+
+#define VIOCHAR_WINDOW          10
+#define VIOCHAR_HIGHWATERMARK   3
+
+enum viocharsubtype {
+        viocharopen = 0x0001,
+        viocharclose = 0x0002,
+        viochardata = 0x0003,
+        viocharack = 0x0004,
+        viocharconfig = 0x0005
+};
+
+enum viochar_rc {
+        viochar_rc_ebusy = 1
+};
+
+#define VIOCHAR_NUM_BUF         16
+
+/*
+ * Our port information.  We store a pointer to one entry in the
+ * tty_driver_data
+ */
+static struct port_info {
+        int magic;
+        struct tty_struct *tty;
+        HvLpIndex lp;
+        u8 vcons;
+        u64 seq;        /* sequence number of last HV send */
+        u64 ack;        /* last ack from HV */
+/*
+ * When we get writes faster than we can send it to the partition,
+ * buffer the data here. Note that used is a bit map of used buffers.
+ * It had better have enough bits to hold VIOCHAR_NUM_BUF the bitops assume
+ * it is a multiple of unsigned long
+ */
+        unsigned long used;
+        u8 *buffer[VIOCHAR_NUM_BUF];
+        int bufferBytes[VIOCHAR_NUM_BUF];
+        int curbuf;
+        int bufferOverflow;
+        int overflowMessage;
+} port_info[VTTY_PORTS];
+
+#define viochar_is_console(pi)  ((pi) == &port_info[0])
+#define viochar_port(pi)        ((pi) - &port_info[0])
+
+static void initDataEvent(struct viocharlpevent *viochar, HvLpIndex lp);
+
+static struct tty_driver *viotty_driver;
+
+void hvlog(char *fmt, ...)
+{
+        int i;
+        unsigned long flags;
+        va_list args;
+        static char buf[256];
+
+        spin_lock_irqsave(&consoleloglock, flags);
+        va_start(args, fmt);
+        i = vscnprintf(buf, sizeof(buf) - 1, fmt, args);
+        va_end(args);
+        buf[i++] = '\r';
+        HvCall_writeLogBuffer(buf, i);
+        spin_unlock_irqrestore(&consoleloglock, flags);
+}
+
+void hvlogOutput(const char *buf, int count)
+{
+        unsigned long flags;
+        int begin;
+        int index;
+        static const char cr = '\r';
+
+        begin = 0;
+        spin_lock_irqsave(&consoleloglock, flags);
+        for (index = 0; index < count; index++) {
+                if (buf[index] == '\n') {
+                        /*
+                         * Start right after the last '\n' or at the zeroth
+                         * array position and output the number of characters
+                         * including the newline.
+                         */
+                        HvCall_writeLogBuffer(&buf[begin], index - begin + 1);
+                        begin = index + 1;
+                        HvCall_writeLogBuffer(&cr, 1);
+                }
+        }
+        if ((index - begin) > 0)
+                HvCall_writeLogBuffer(&buf[begin], index - begin);
+        spin_unlock_irqrestore(&consoleloglock, flags);
+}
+
+/*
+ * Make sure we're pointing to a valid port_info structure.  Shamelessly
+ * plagerized from serial.c
+ */
+static inline int viotty_paranoia_check(struct port_info *pi,
+                                        char *name, const char *routine)
+{
+        static const char *bad_pi_addr = VIOCONS_KERN_WARN
+                "warning: bad address for port_info struct (%s) in %s\n";
+        static const char *badmagic = VIOCONS_KERN_WARN
+                "warning: bad magic number for port_info struct (%s) in %s\n";
+
+        if ((pi < &port_info[0]) || (viochar_port(pi) > VTTY_PORTS)) {
+                printk(bad_pi_addr, name, routine);
+                return 1;
+        }
+        if (pi->magic != VIOTTY_MAGIC) {
+                printk(badmagic, name, routine);
+                return 1;
+        }
+        return 0;
+}
+
+/*
+ * Add data to our pending-send buffers.  
+ *
+ * NOTE: Don't use printk in here because it gets nastily recursive.
+ * hvlog can be used to log to the hypervisor buffer
+ */
+static int buffer_add(struct port_info *pi, const char *buf, size_t len)
+{
+        size_t bleft;
+        size_t curlen;
+        const char *curbuf;
+        int nextbuf;
+
+        curbuf = buf;
+        bleft = len;
+        while (bleft > 0) {
+                /*
+                 * If there is no space left in the current buffer, we have
+                 * filled everything up, so return.  If we filled the previous
+                 * buffer we would already have moved to the next one.
+                 */
+                if (pi->bufferBytes[pi->curbuf] == VIOCHAR_MAX_DATA) {
+                        hvlog ("\n\rviocons: No overflow buffer available for memcpy().\n");
+                        pi->bufferOverflow++;
+                        pi->overflowMessage = 1;
+                        break;
+                }
+
+                /*
+                 * Turn on the "used" bit for this buffer.  If it's already on,
+                 * that's fine.
+                 */
+                set_bit(pi->curbuf, &pi->used);
+
+                /*
+                 * See if this buffer has been allocated.  If not, allocate it.
+                 */
+                if (pi->buffer[pi->curbuf] == NULL) {
+                        pi->buffer[pi->curbuf] =
+                            kmalloc(VIOCHAR_MAX_DATA, GFP_ATOMIC);
+                        if (pi->buffer[pi->curbuf] == NULL) {
+                                hvlog("\n\rviocons: kmalloc failed allocating spaces for buffer %d.",
+                                        pi->curbuf);
+                                break;
+                        }
+                }
+
+                /* Figure out how much we can copy into this buffer. */
+                if (bleft < (VIOCHAR_MAX_DATA - pi->bufferBytes[pi->curbuf]))
+                        curlen = bleft;
+                else
+                        curlen = VIOCHAR_MAX_DATA - pi->bufferBytes[pi->curbuf];
+
+                /* Copy the data into the buffer. */
+                memcpy(pi->buffer[pi->curbuf] + pi->bufferBytes[pi->curbuf],
+                                curbuf, curlen);
+
+                pi->bufferBytes[pi->curbuf] += curlen;
+                curbuf += curlen;
+                bleft -= curlen;
+
+                /*
+                 * Now see if we've filled this buffer.  If not then
+                 * we'll try to use it again later.  If we've filled it
+                 * up then we'll advance the curbuf to the next in the
+                 * circular queue.
+                 */
+                if (pi->bufferBytes[pi->curbuf] == VIOCHAR_MAX_DATA) {
+                        nextbuf = (pi->curbuf + 1) % VIOCHAR_NUM_BUF;
+                        /*
+                         * Move to the next buffer if it hasn't been used yet
+                         */
+                        if (test_bit(nextbuf, &pi->used) == 0)
+                                pi->curbuf = nextbuf;
+                }
+        }
+        return len - bleft;
+}
+
+/*
+ * Send pending data
+ *
+ * NOTE: Don't use printk in here because it gets nastily recursive.
+ * hvlog can be used to log to the hypervisor buffer
+ */
+static void send_buffers(struct port_info *pi)
+{
+        HvLpEvent_Rc hvrc;
+        int nextbuf;
+        struct viocharlpevent *viochar;
+        unsigned long flags;
+
+        spin_lock_irqsave(&consolelock, flags);
+
+        viochar = (struct viocharlpevent *)
+            vio_get_event_buffer(viomajorsubtype_chario);
+
+        /* Make sure we got a buffer */
+        if (viochar == NULL) {
+                hvlog("\n\rviocons: Can't get viochar buffer in sendBuffers().");
+                spin_unlock_irqrestore(&consolelock, flags);
+                return;
+        }
+
+        if (pi->used == 0) {
+                hvlog("\n\rviocons: in sendbuffers(), but no buffers used.\n");
+                vio_free_event_buffer(viomajorsubtype_chario, viochar);
+                spin_unlock_irqrestore(&consolelock, flags);
+                return;
+        }
+
+        /*
+         * curbuf points to the buffer we're filling.  We want to
+         * start sending AFTER this one.  
+         */
+        nextbuf = (pi->curbuf + 1) % VIOCHAR_NUM_BUF;
+
+        /*
+         * Loop until we find a buffer with the used bit on
+         */
+        while (test_bit(nextbuf, &pi->used) == 0)
+                nextbuf = (nextbuf + 1) % VIOCHAR_NUM_BUF;
+
+        initDataEvent(viochar, pi->lp);
+
+        /*
+         * While we have buffers with data, and our send window
+         * is open, send them
+         */
+        while ((test_bit(nextbuf, &pi->used)) &&
+               ((pi->seq - pi->ack) < VIOCHAR_WINDOW)) {
+                viochar->len = pi->bufferBytes[nextbuf];
+                viochar->event.xCorrelationToken = pi->seq++;
+                viochar->event.xSizeMinus1 =
+                        offsetof(struct viocharlpevent, data) + viochar->len;
+
+                memcpy(viochar->data, pi->buffer[nextbuf], viochar->len);
+
+                hvrc = HvCallEvent_signalLpEvent(&viochar->event);
+                if (hvrc) {
+                        /*
+                         * MUST unlock the spinlock before doing a printk
+                         */
+                        vio_free_event_buffer(viomajorsubtype_chario, viochar);
+                        spin_unlock_irqrestore(&consolelock, flags);
+
+                        printk(VIOCONS_KERN_WARN
+                               "error sending event! return code %d\n",
+                               (int)hvrc);
+                        return;
+                }
+
+                /*
+                 * clear the used bit, zero the number of bytes in
+                 * this buffer, and move to the next buffer
+                 */
+                clear_bit(nextbuf, &pi->used);
+                pi->bufferBytes[nextbuf] = 0;
+                nextbuf = (nextbuf + 1) % VIOCHAR_NUM_BUF;
+        }
+
+        /*
+         * If we have emptied all the buffers, start at 0 again.
+         * this will re-use any allocated buffers
+         */
+        if (pi->used == 0) {
+                pi->curbuf = 0;
+
+                if (pi->overflowMessage)
+                        pi->overflowMessage = 0;
+
+                if (pi->tty) {
+                        tty_wakeup(pi->tty);
+                }
+        }
+
+        vio_free_event_buffer(viomajorsubtype_chario, viochar);
+        spin_unlock_irqrestore(&consolelock, flags);
+}
+
+/*
+ * Our internal writer.  Gets called both from the console device and
+ * the tty device.  the tty pointer will be NULL if called from the console.
+ * Return total number of bytes "written".
+ *
+ * NOTE: Don't use printk in here because it gets nastily recursive.  hvlog
+ * can be used to log to the hypervisor buffer
+ */
+static int internal_write(struct port_info *pi, const char *buf, size_t len)
+{
+        HvLpEvent_Rc hvrc;
+        size_t bleft;
+        size_t curlen;
+        const char *curbuf;
+        unsigned long flags;
+        struct viocharlpevent *viochar;
+
+        /*
+         * Write to the hvlog of inbound data are now done prior to
+         * calling internal_write() since internal_write() is only called in
+         * the event that an lp event path is active, which isn't the case for
+         * logging attempts prior to console initialization.
+         *
+         * If there is already data queued for this port, send it prior to
+         * attempting to send any new data.
+         */
+        if (pi->used)
+                send_buffers(pi);
+
+        spin_lock_irqsave(&consolelock, flags);
+
+        viochar = vio_get_event_buffer(viomajorsubtype_chario);
+        if (viochar == NULL) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                hvlog("\n\rviocons: Can't get vio buffer in internal_write().");
+                return -EAGAIN;
+        }
+        initDataEvent(viochar, pi->lp);
+
+        curbuf = buf;
+        bleft = len;
+
+        while ((bleft > 0) && (pi->used == 0) &&
+               ((pi->seq - pi->ack) < VIOCHAR_WINDOW)) {
+                if (bleft > VIOCHAR_MAX_DATA)
+                        curlen = VIOCHAR_MAX_DATA;
+                else
+                        curlen = bleft;
+
+                viochar->event.xCorrelationToken = pi->seq++;
+                memcpy(viochar->data, curbuf, curlen);
+                viochar->len = curlen;
+                viochar->event.xSizeMinus1 =
+                    offsetof(struct viocharlpevent, data) + curlen;
+
+                hvrc = HvCallEvent_signalLpEvent(&viochar->event);
+                if (hvrc) {
+                        hvlog("viocons: error sending event! %d\n", (int)hvrc);
+                        goto out;
+                }
+                curbuf += curlen;
+                bleft -= curlen;
+        }
+
+        /* If we didn't send it all, buffer as much of it as we can. */
+        if (bleft > 0)
+                bleft -= buffer_add(pi, curbuf, bleft);
+out:
+        vio_free_event_buffer(viomajorsubtype_chario, viochar);
+        spin_unlock_irqrestore(&consolelock, flags);
+        return len - bleft;
+}
+
+static struct port_info *get_port_data(struct tty_struct *tty)
+{
+        unsigned long flags;
+        struct port_info *pi;
+
+        spin_lock_irqsave(&consolelock, flags);
+        if (tty) {
+                pi = (struct port_info *)tty->driver_data;
+                if (!pi || viotty_paranoia_check(pi, tty->name,
+                                             "get_port_data")) {
+                        pi = NULL;
+                }
+        } else
+                /*
+                 * If this is the console device, use the lp from
+                 * the first port entry
+                 */
+                pi = &port_info[0];
+        spin_unlock_irqrestore(&consolelock, flags);
+        return pi;
+}
+
+/*
+ * Initialize the common fields in a charLpEvent
+ */
+static void initDataEvent(struct viocharlpevent *viochar, HvLpIndex lp)
+{
+        memset(viochar, 0, sizeof(struct viocharlpevent));
+
+        viochar->event.xFlags.xValid = 1;
+        viochar->event.xFlags.xFunction = HvLpEvent_Function_Int;
+        viochar->event.xFlags.xAckInd = HvLpEvent_AckInd_NoAck;
+        viochar->event.xFlags.xAckType = HvLpEvent_AckType_DeferredAck;
+        viochar->event.xType = HvLpEvent_Type_VirtualIo;
+        viochar->event.xSubtype = viomajorsubtype_chario | viochardata;
+        viochar->event.xSourceLp = HvLpConfig_getLpIndex();
+        viochar->event.xTargetLp = lp;
+        viochar->event.xSizeMinus1 = sizeof(struct viocharlpevent);
+        viochar->event.xSourceInstanceId = viopath_sourceinst(lp);
+        viochar->event.xTargetInstanceId = viopath_targetinst(lp);
+}
+
+/*
+ * early console device write
+ */
+static void viocons_write_early(struct console *co, const char *s, unsigned count)
+{
+        hvlogOutput(s, count);
+}
+
+/*
+ * console device write
+ */
+static void viocons_write(struct console *co, const char *s, unsigned count)
+{
+        int index;
+        int begin;
+        struct port_info *pi;
+
+        static const char cr = '\r';
+
+        /*
+         * Check port data first because the target LP might be valid but
+         * simply not active, in which case we want to hvlog the output.
+         */
+        pi = get_port_data(NULL);
+        if (pi == NULL) {
+                hvlog("\n\rviocons_write: unable to get port data.");
+                return;
+        }
+
+        hvlogOutput(s, count);
+
+        if (!viopath_isactive(pi->lp))
+                return;
+
+        /* 
+         * Any newline character found will cause a
+         * carriage return character to be emitted as well. 
+         */
+        begin = 0;
+        for (index = 0; index < count; index++) {
+                if (s[index] == '\n') {
+                        /* 
+                         * Newline found. Print everything up to and 
+                         * including the newline
+                         */
+                        internal_write(pi, &s[begin], index - begin + 1);
+                        begin = index + 1;
+                        /* Emit a carriage return as well */
+                        internal_write(pi, &cr, 1);
+                }
+        }
+
+        /* If any characters left to write, write them now */
+        if ((index - begin) > 0)
+                internal_write(pi, &s[begin], index - begin);
+}
+
+/*
+ * Work out the device associate with this console
+ */
+static struct tty_driver *viocons_device(struct console *c, int *index)
+{
+        *index = c->index;
+        return viotty_driver;
+}
+
+/*
+ * console device I/O methods
+ */
+static struct console viocons_early = {
+        .name = "viocons",
+        .write = viocons_write_early,
+        .flags = CON_PRINTBUFFER,
+        .index = -1,
+};
+
+static struct console viocons = {
+        .name = "viocons",
+        .write = viocons_write,
+        .device = viocons_device,
+        .flags = CON_PRINTBUFFER,
+        .index = -1,
+};
+
+/*
+ * TTY Open method
+ */
+static int viotty_open(struct tty_struct *tty, struct file *filp)
+{
+        int port;
+        unsigned long flags;
+        struct port_info *pi;
+
+        port = tty->index;
+
+        if ((port < 0) || (port >= VTTY_PORTS))
+                return -ENODEV;
+
+        spin_lock_irqsave(&consolelock, flags);
+
+        pi = &port_info[port];
+        /* If some other TTY is already connected here, reject the open */
+        if ((pi->tty) && (pi->tty != tty)) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                printk(VIOCONS_KERN_WARN
+                       "attempt to open device twice from different ttys\n");
+                return -EBUSY;
+        }
+        tty->driver_data = pi;
+        pi->tty = tty;
+        spin_unlock_irqrestore(&consolelock, flags);
+
+        return 0;
+}
+
+/*
+ * TTY Close method
+ */
+static void viotty_close(struct tty_struct *tty, struct file *filp)
+{
+        unsigned long flags;
+        struct port_info *pi;
+
+        spin_lock_irqsave(&consolelock, flags);
+        pi = (struct port_info *)tty->driver_data;
+
+        if (!pi || viotty_paranoia_check(pi, tty->name, "viotty_close")) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                return;
+        }
+        if (tty->count == 1)
+                pi->tty = NULL;
+        spin_unlock_irqrestore(&consolelock, flags);
+}
+
+/*
+ * TTY Write method
+ */
+static int viotty_write(struct tty_struct *tty, const unsigned char *buf,
+                int count)
+{
+        struct port_info *pi;
+
+        pi = get_port_data(tty);
+        if (pi == NULL) {
+                hvlog("\n\rviotty_write: no port data.");
+                return -ENODEV;
+        }
+
+        if (viochar_is_console(pi))
+                hvlogOutput(buf, count);
+
+        /*
+         * If the path to this LP is closed, don't bother doing anything more.
+         * just dump the data on the floor and return count.  For some reason
+         * some user level programs will attempt to probe available tty's and
+         * they'll attempt a viotty_write on an invalid port which maps to an
+         * invalid target lp.  If this is the case then ignore the
+         * viotty_write call and, since the viopath isn't active to this
+         * partition, return count.
+         */
+        if (!viopath_isactive(pi->lp))
+                return count;
+
+        return internal_write(pi, buf, count);
+}
+
+/*
+ * TTY put_char method
+ */
+static void viotty_put_char(struct tty_struct *tty, unsigned char ch)
+{
+        struct port_info *pi;
+
+        pi = get_port_data(tty);
+        if (pi == NULL)
+                return;
+
+        /* This will append '\r' as well if the char is '\n' */
+        if (viochar_is_console(pi))
+                hvlogOutput(&ch, 1);
+
+        if (viopath_isactive(pi->lp))
+                internal_write(pi, &ch, 1);
+}
+
+/*
+ * TTY write_room method
+ */
+static int viotty_write_room(struct tty_struct *tty)
+{
+        int i;
+        int room = 0;
+        struct port_info *pi;
+        unsigned long flags;
+
+        spin_lock_irqsave(&consolelock, flags);
+        pi = (struct port_info *)tty->driver_data;
+        if (!pi || viotty_paranoia_check(pi, tty->name, "viotty_write_room")) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                return 0;
+        }
+
+        /* If no buffers are used, return the max size. */
+        if (pi->used == 0) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                return VIOCHAR_MAX_DATA * VIOCHAR_NUM_BUF;
+        }
+
+        /*
+         * We retain the spinlock because we want to get an accurate
+         * count and it can change on us between each operation if we
+         * don't hold the spinlock.
+         */
+        for (i = 0; ((i < VIOCHAR_NUM_BUF) && (room < VIOCHAR_MAX_DATA)); i++)
+                room += (VIOCHAR_MAX_DATA - pi->bufferBytes[i]);
+        spin_unlock_irqrestore(&consolelock, flags);
+
+        if (room > VIOCHAR_MAX_DATA)
+                room = VIOCHAR_MAX_DATA;
+        return room;
+}
+
+/*
+ * TTY chars_in_buffer method
+ */
+static int viotty_chars_in_buffer(struct tty_struct *tty)
+{
+        return 0;
+}
+
+static int viotty_ioctl(struct tty_struct *tty, struct file *file,
+                        unsigned int cmd, unsigned long arg)
+{
+        switch (cmd) {
+        /*
+         * the ioctls below read/set the flags usually shown in the leds
+         * don't use them - they will go away without warning
+         */
+        case KDGETLED:
+        case KDGKBLED:
+                return put_user(0, (char *)arg);
+
+        case KDSKBLED:
+                return 0;
+        }
+
+        return n_tty_ioctl(tty, file, cmd, arg);
+}
+
+/*
+ * Handle an open charLpEvent.  Could be either interrupt or ack
+ */
+static void vioHandleOpenEvent(struct HvLpEvent *event)
+{
+        unsigned long flags;
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+        u8 port = cevent->virtual_device;
+        struct port_info *pi;
+        int reject = 0;
+
+        if (event->xFlags.xFunction == HvLpEvent_Function_Ack) {
+                if (port >= VTTY_PORTS)
+                        return;
+
+                spin_lock_irqsave(&consolelock, flags);
+                /* Got the lock, don't cause console output */
+
+                pi = &port_info[port];
+                if (event->xRc == HvLpEvent_Rc_Good) {
+                        pi->seq = pi->ack = 0;
+                        /*
+                         * This line allows connections from the primary
+                         * partition but once one is connected from the
+                         * primary partition nothing short of a reboot
+                         * of linux will allow access from the hosting
+                         * partition again without a required iSeries fix.
+                         */
+                        pi->lp = event->xTargetLp;
+                }
+
+                spin_unlock_irqrestore(&consolelock, flags);
+                if (event->xRc != HvLpEvent_Rc_Good)
+                        printk(VIOCONS_KERN_WARN
+                               "handle_open_event: event->xRc == (%d).\n",
+                               event->xRc);
+
+                if (event->xCorrelationToken != 0) {
+                        atomic_t *aptr= (atomic_t *)event->xCorrelationToken;
+                        atomic_set(aptr, 1);
+                } else
+                        printk(VIOCONS_KERN_WARN
+                               "weird...got open ack without atomic\n");
+                return;
+        }
+
+        /* This had better require an ack, otherwise complain */
+        if (event->xFlags.xAckInd != HvLpEvent_AckInd_DoAck) {
+                printk(VIOCONS_KERN_WARN "viocharopen without ack bit!\n");
+                return;
+        }
+
+        spin_lock_irqsave(&consolelock, flags);
+        /* Got the lock, don't cause console output */
+
+        /* Make sure this is a good virtual tty */
+        if (port >= VTTY_PORTS) {
+                event->xRc = HvLpEvent_Rc_SubtypeError;
+                cevent->subtype_result_code = viorc_openRejected;
+                /*
+                 * Flag state here since we can't printk while holding
+                 * a spinlock.
+                 */
+                reject = 1;
+        } else {
+                pi = &port_info[port];
+                if ((pi->lp != HvLpIndexInvalid) &&
+                                (pi->lp != event->xSourceLp)) {
+                        /*
+                         * If this is tty is already connected to a different
+                         * partition, fail.
+                         */
+                        event->xRc = HvLpEvent_Rc_SubtypeError;
+                        cevent->subtype_result_code = viorc_openRejected;
+                        reject = 2;
+                } else {
+                        pi->lp = event->xSourceLp;
+                        event->xRc = HvLpEvent_Rc_Good;
+                        cevent->subtype_result_code = viorc_good;
+                        pi->seq = pi->ack = 0;
+                        reject = 0;
+                }
+        }
+
+        spin_unlock_irqrestore(&consolelock, flags);
+
+        if (reject == 1)
+                printk(VIOCONS_KERN_WARN "open rejected: bad virtual tty.\n");
+        else if (reject == 2)
+                printk(VIOCONS_KERN_WARN
+                        "open rejected: console in exclusive use by another partition.\n");
+
+        /* Return the acknowledgement */
+        HvCallEvent_ackLpEvent(event);
+}
+
+/*
+ * Handle a close charLpEvent.  This should ONLY be an Interrupt because the
+ * virtual console should never actually issue a close event to the hypervisor
+ * because the virtual console never goes away.  A close event coming from the
+ * hypervisor simply means that there are no client consoles connected to the
+ * virtual console.
+ *
+ * Regardless of the number of connections masqueraded on the other side of
+ * the hypervisor ONLY ONE close event should be called to accompany the ONE
+ * open event that is called.  The close event should ONLY be called when NO
+ * MORE connections (masqueraded or not) exist on the other side of the
+ * hypervisor.
+ */
+static void vioHandleCloseEvent(struct HvLpEvent *event)
+{
+        unsigned long flags;
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+        u8 port = cevent->virtual_device;
+
+        if (event->xFlags.xFunction == HvLpEvent_Function_Int) {
+                if (port >= VTTY_PORTS) {
+                        printk(VIOCONS_KERN_WARN
+                                        "close message from invalid virtual device.\n");
+                        return;
+                }
+
+                /* For closes, just mark the console partition invalid */
+                spin_lock_irqsave(&consolelock, flags);
+                /* Got the lock, don't cause console output */
+
+                if (port_info[port].lp == event->xSourceLp)
+                        port_info[port].lp = HvLpIndexInvalid;
+
+                spin_unlock_irqrestore(&consolelock, flags);
+                printk(VIOCONS_KERN_INFO "close from %d\n", event->xSourceLp);
+        } else
+                printk(VIOCONS_KERN_WARN
+                                "got unexpected close acknowlegement\n");
+}
+
+/*
+ * Handle a config charLpEvent.  Could be either interrupt or ack
+ */
+static void vioHandleConfig(struct HvLpEvent *event)
+{
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+
+        HvCall_writeLogBuffer(cevent->data, cevent->len);
+
+        if (cevent->data[0] == 0x01)
+                printk(VIOCONS_KERN_INFO "window resized to %d: %d: %d: %d\n",
+                       cevent->data[1], cevent->data[2],
+                       cevent->data[3], cevent->data[4]);
+        else
+                printk(VIOCONS_KERN_WARN "unknown config event\n");
+}
+
+/*
+ * Handle a data charLpEvent. 
+ */
+static void vioHandleData(struct HvLpEvent *event)
+{
+        struct tty_struct *tty;
+        unsigned long flags;
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+        struct port_info *pi;
+        int index;
+        u8 port = cevent->virtual_device;
+
+        if (port >= VTTY_PORTS) {
+                printk(VIOCONS_KERN_WARN "data on invalid virtual device %d\n",
+                                port);
+                return;
+        }
+
+        /*
+         * Hold the spinlock so that we don't take an interrupt that
+         * changes tty between the time we fetch the port_info
+         * pointer and the time we paranoia check.
+         */
+        spin_lock_irqsave(&consolelock, flags);
+        pi = &port_info[port];
+
+        /*
+         * Change 05/01/2003 - Ryan Arnold: If a partition other than
+         * the current exclusive partition tries to send us data
+         * events then just drop them on the floor because we don't
+         * want his stinking data.  He isn't authorized to receive
+         * data because he wasn't the first one to get the console,
+         * therefore he shouldn't be allowed to send data either.
+         * This will work without an iSeries fix.
+         */
+        if (pi->lp != event->xSourceLp) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                return;
+        }
+
+        tty = pi->tty;
+        if (tty == NULL) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                printk(VIOCONS_KERN_WARN "no tty for virtual device %d\n",
+                                port);
+                return;
+        }
+
+        if (tty->magic != TTY_MAGIC) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                printk(VIOCONS_KERN_WARN "tty bad magic\n");
+                return;
+        }
+
+        /*
+         * Just to be paranoid, make sure the tty points back to this port
+         */
+        pi = (struct port_info *)tty->driver_data;
+        if (!pi || viotty_paranoia_check(pi, tty->name, "vioHandleData")) {
+                spin_unlock_irqrestore(&consolelock, flags);
+                return;
+        }
+        spin_unlock_irqrestore(&consolelock, flags);
+
+        /*
+         * Change 07/21/2003 - Ryan Arnold: functionality added to
+         * support sysrq utilizing ^O as the sysrq key.  The sysrq
+         * functionality will only work if built into the kernel and
+         * then only if sysrq is enabled through the proc filesystem.
+         */
+        for (index = 0; index < cevent->len; index++) {
+#ifdef CONFIG_MAGIC_SYSRQ
+                if (sysrq_enabled) {
+                        /* 0x0f is the ascii character for ^O */
+                        if (cevent->data[index] == '\x0f') {
+                                vio_sysrq_pressed = 1;
+                                /*
+                                 * continue because we don't want to add
+                                 * the sysrq key into the data string.
+                                 */
+                                continue;
+                        } else if (vio_sysrq_pressed) {
+                                handle_sysrq(cevent->data[index], NULL, tty);
+                                vio_sysrq_pressed = 0;
+                                /*
+                                 * continue because we don't want to add
+                                 * the sysrq sequence into the data string.
+                                 */
+                                continue;
+                        }
+                }
+#endif
+                /*
+                 * The sysrq sequence isn't included in this check if
+                 * sysrq is enabled and compiled into the kernel because
+                 * the sequence will never get inserted into the buffer.
+                 * Don't attempt to copy more data into the buffer than we
+                 * have room for because it would fail without indication.
+                 */
+                if ((tty->flip.count + 1) > TTY_FLIPBUF_SIZE) {
+                        printk(VIOCONS_KERN_WARN "input buffer overflow!\n");
+                        break;
+                }
+                tty_insert_flip_char(tty, cevent->data[index], TTY_NORMAL);
+        }
+
+        /* if cevent->len == 0 then no data was added to the buffer and flip.count == 0 */
+        if (tty->flip.count)
+                /* The next call resets flip.count when the data is flushed. */
+                tty_flip_buffer_push(tty);
+}
+
+/*
+ * Handle an ack charLpEvent. 
+ */
+static void vioHandleAck(struct HvLpEvent *event)
+{
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+        unsigned long flags;
+        u8 port = cevent->virtual_device;
+
+        if (port >= VTTY_PORTS) {
+                printk(VIOCONS_KERN_WARN "data on invalid virtual device\n");
+                return;
+        }
+
+        spin_lock_irqsave(&consolelock, flags);
+        port_info[port].ack = event->xCorrelationToken;
+        spin_unlock_irqrestore(&consolelock, flags);
+
+        if (port_info[port].used)
+                send_buffers(&port_info[port]);
+}
+
+/*
+ * Handle charLpEvents and route to the appropriate routine
+ */
+static void vioHandleCharEvent(struct HvLpEvent *event)
+{
+        int charminor;
+
+        if (event == NULL)
+                return;
+
+        charminor = event->xSubtype & VIOMINOR_SUBTYPE_MASK;
+        switch (charminor) {
+        case viocharopen:
+                vioHandleOpenEvent(event);
+                break;
+        case viocharclose:
+                vioHandleCloseEvent(event);
+                break;
+        case viochardata:
+                vioHandleData(event);
+                break;
+        case viocharack:
+                vioHandleAck(event);
+                break;
+        case viocharconfig:
+                vioHandleConfig(event);
+                break;
+        default:
+                if ((event->xFlags.xFunction == HvLpEvent_Function_Int) &&
+                    (event->xFlags.xAckInd == HvLpEvent_AckInd_DoAck)) {
+                        event->xRc = HvLpEvent_Rc_InvalidSubtype;
+                        HvCallEvent_ackLpEvent(event);
+                }
+        }
+}
+
+/*
+ * Send an open event
+ */
+static int send_open(HvLpIndex remoteLp, void *sem)
+{
+        return HvCallEvent_signalLpEventFast(remoteLp,
+                        HvLpEvent_Type_VirtualIo,
+                        viomajorsubtype_chario | viocharopen,
+                        HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
+                        viopath_sourceinst(remoteLp),
+                        viopath_targetinst(remoteLp),
+                        (u64)(unsigned long)sem, VIOVERSION << 16,
+                        0, 0, 0, 0);
+}
+
+static struct tty_operations serial_ops = {
+        .open = viotty_open,
+        .close = viotty_close,
+        .write = viotty_write,
+        .put_char = viotty_put_char,
+        .write_room = viotty_write_room,
+        .chars_in_buffer = viotty_chars_in_buffer,
+        .ioctl = viotty_ioctl,
+};
+
+static int __init viocons_init2(void)
+{
+        atomic_t wait_flag;
+        int rc;
+
+        /* +2 for fudge */
+        rc = viopath_open(HvLpConfig_getPrimaryLpIndex(),
+                        viomajorsubtype_chario, VIOCHAR_WINDOW + 2);
+        if (rc)
+                printk(VIOCONS_KERN_WARN "error opening to primary %d\n", rc);
+
+        if (viopath_hostLp == HvLpIndexInvalid)
+                vio_set_hostlp();
+
+        /*
+         * And if the primary is not the same as the hosting LP, open to the 
+         * hosting lp
+         */
+        if ((viopath_hostLp != HvLpIndexInvalid) &&
+            (viopath_hostLp != HvLpConfig_getPrimaryLpIndex())) {
+                printk(VIOCONS_KERN_INFO "open path to hosting (%d)\n",
+                                viopath_hostLp);
+                rc = viopath_open(viopath_hostLp, viomajorsubtype_chario,
+                                VIOCHAR_WINDOW + 2);    /* +2 for fudge */
+                if (rc)
+                        printk(VIOCONS_KERN_WARN
+                                "error opening to partition %d: %d\n",
+                                viopath_hostLp, rc);
+        }
+
+        if (vio_setHandler(viomajorsubtype_chario, vioHandleCharEvent) < 0)
+                printk(VIOCONS_KERN_WARN
+                                "error seting handler for console events!\n");
+
+        /*
+         * First, try to open the console to the hosting lp.
+         * Wait on a semaphore for the response.
+         */
+        atomic_set(&wait_flag, 0);
+        if ((viopath_isactive(viopath_hostLp)) &&
+            (send_open(viopath_hostLp, (void *)&wait_flag) == 0)) {
+                printk(VIOCONS_KERN_INFO "hosting partition %d\n",
+                        viopath_hostLp);
+                while (atomic_read(&wait_flag) == 0)
+                        mb();
+                atomic_set(&wait_flag, 0);
+        }
+
+        /*
+         * If we don't have an active console, try the primary
+         */
+        if ((!viopath_isactive(port_info[0].lp)) &&
+            (viopath_isactive(HvLpConfig_getPrimaryLpIndex())) &&
+            (send_open(HvLpConfig_getPrimaryLpIndex(), (void *)&wait_flag)
+             == 0)) {
+                printk(VIOCONS_KERN_INFO "opening console to primary partition\n");
+                while (atomic_read(&wait_flag) == 0)
+                        mb();
+        }
+
+        /* Initialize the tty_driver structure */
+        viotty_driver = alloc_tty_driver(VTTY_PORTS);
+        viotty_driver->owner = THIS_MODULE;
+        viotty_driver->driver_name = "vioconsole";
+        viotty_driver->devfs_name = "vcs/";
+        viotty_driver->name = "tty";
+        viotty_driver->name_base = 1;
+        viotty_driver->major = TTY_MAJOR;
+        viotty_driver->minor_start = 1;
+        viotty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
+        viotty_driver->subtype = 1;
+        viotty_driver->init_termios = tty_std_termios;
+        viotty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
+        tty_set_operations(viotty_driver, &serial_ops);
+
+        if (tty_register_driver(viotty_driver)) {
+                printk(VIOCONS_KERN_WARN "couldn't register console driver\n");
+                put_tty_driver(viotty_driver);
+                viotty_driver = NULL;
+        }
+
+        unregister_console(&viocons_early);
+        register_console(&viocons);
+
+        return 0;
+}
+
+static int __init viocons_init(void)
+{
+        int i;
+
+        printk(VIOCONS_KERN_INFO "registering console\n");
+        for (i = 0; i < VTTY_PORTS; i++) {
+                port_info[i].lp = HvLpIndexInvalid;
+                port_info[i].magic = VIOTTY_MAGIC;
+        }
+        HvCall_setLogBufferFormatAndCodepage(HvCall_LogBuffer_ASCII, 437);
+        register_console(&viocons_early);
+        return 0;
+}
+
+console_initcall(viocons_init);
+module_init(viocons_init2);