--- /dev/null
+/* -*- 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 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 VIOTTY_SERIAL_START 65
+
+static spinlock_t consolelock = SPIN_LOCK_UNLOCKED;
+static spinlock_t consoleloglock = SPIN_LOCK_UNLOCKED;
+
+#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];
+};
+
+/*
+ * This is a place where we handle the distribution of memory
+ * for copy_from_user() calls. The buffer_available array is to
+ * help us determine which buffer to use.
+ */
+#define VIOCHAR_NUM_CFU_BUFFERS 7
+static struct viocharlpevent viocons_cfu_buffer[VIOCHAR_NUM_CFU_BUFFERS];
+static atomic_t viocons_cfu_buffer_available[VIOCHAR_NUM_CFU_BUFFERS];
+
+#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;
+static struct tty_driver *viottyS_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 = vsnprintf(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 = KERN_WARNING_VIO
+ "Warning: bad address for port_info struct (%s) in %s\n";
+ static const char *badmagic = KERN_WARNING_VIO
+ "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;
+}
+
+/*
+ * This function should ONLY be called once from viocons_init2
+ */
+static void viocons_init_cfu_buffer(void)
+{
+ int i;
+
+ for (i = 1; i < VIOCHAR_NUM_CFU_BUFFERS; i++)
+ atomic_set(&viocons_cfu_buffer_available[i], 1);
+}
+
+static struct viocharlpevent *viocons_get_cfu_buffer(void)
+{
+ int i;
+
+ /*
+ * Grab the first available buffer. It doesn't matter if we
+ * are interrupted during this array traversal as long as we
+ * get an available space.
+ */
+ for (i = 0; i < VIOCHAR_NUM_CFU_BUFFERS; i++)
+ if (atomic_dec_if_positive(&viocons_cfu_buffer_available[i])
+ == 0 )
+ return &viocons_cfu_buffer[i];
+ hvlog("\n\rviocons: viocons_get_cfu_buffer : no free buffers found");
+ return NULL;
+}
+
+static void viocons_free_cfu_buffer(struct viocharlpevent *buffer)
+{
+ int i;
+
+ i = buffer - &viocons_cfu_buffer[0];
+ if (i >= (sizeof(viocons_cfu_buffer) / sizeof(viocons_cfu_buffer[0]))) {
+ hvlog("\n\rviocons: viocons_free_cfu_buffer : buffer pointer not found in list.");
+ return;
+ }
+ if (atomic_read(&viocons_cfu_buffer_available[i]) != 0) {
+ hvlog("\n\rviocons: WARNING : returning unallocated cfu buffer.");
+ return;
+ }
+ atomic_set(&viocons_cfu_buffer_available[i], 1);
+}
+
+/*
+ * 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(KERN_WARNING_VIO
+ "console 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) {
+ if ((pi->tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
+ (pi->tty->ldisc.write_wakeup))
+ (pi->tty->ldisc.write_wakeup)(pi->tty);
+ wake_up_interruptible(&pi->tty->write_wait);
+ }
+ }
+
+ 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, struct viocharlpevent *viochar)
+{
+ HvLpEvent_Rc hvrc;
+ size_t bleft;
+ size_t curlen;
+ const char *curbuf;
+ unsigned long flags;
+ int copy_needed = (viochar == NULL);
+
+ /*
+ * 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);
+
+ /*
+ * If the internal_write() was passed a pointer to a
+ * viocharlpevent then we don't need to allocate a new one
+ * (this is the case where we are internal_writing user space
+ * data). If we aren't writing user space data then we need
+ * to get an event from viopath.
+ */
+ if (copy_needed) {
+ /* This one is fetched from the viopath data structure */
+ viochar = (struct viocharlpevent *)
+ vio_get_event_buffer(viomajorsubtype_chario);
+ /* Make sure we got a buffer */
+ if (viochar == NULL) {
+ spin_unlock_irqrestore(&consolelock, flags);
+ hvlog("\n\rviocons: Can't get viochar 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++;
+
+ if (copy_needed) {
+ memcpy(viochar->data, curbuf, curlen);
+ viochar->len = curlen;
+ }
+
+ viochar->event.xSizeMinus1 =
+ offsetof(struct viocharlpevent, data) + curlen;
+
+ hvrc = HvCallEvent_signalLpEvent(&viochar->event);
+ if (hvrc) {
+ spin_unlock_irqrestore(&consolelock, flags);
+ if (copy_needed)
+ vio_free_event_buffer(viomajorsubtype_chario, viochar);
+
+ hvlog("viocons: error sending event! %d\n", (int)hvrc);
+ return len - bleft;
+ }
+
+ 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);
+ /*
+ * Since we grabbed it from the viopath data structure, return
+ * it to the data structure.
+ */
+ if (copy_needed)
+ 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)) {
+ /*
+ * This is a VERY noisy trace message in the case where the
+ * path manager is not active or in the case where this
+ * function is called prior to viocons initialization. It is
+ * being commented out for the sake of a clear trace buffer.
+ */
+#if 0
+ hvlog("\n\rviocons_write: path not active to lp %d", pi->lp);
+#endif
+ 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,
+ NULL);
+ begin = index + 1;
+ /* Emit a carriage return as well */
+ internal_write(pi, &cr, 1, NULL);
+ }
+ }
+
+ /* If any characters left to write, write them now */
+ if ((index - begin) > 0)
+ internal_write(pi, &s[begin], index - begin, NULL);
+}
+
+/*
+ * 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 = "ttyS",
+ .write = viocons_write_early,
+ .flags = CON_PRINTBUFFER,
+ .index = -1,
+};
+
+static struct console viocons = {
+ .name = "ttyS",
+ .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 >= VIOTTY_SERIAL_START)
+ port -= VIOTTY_SERIAL_START;
+
+ 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(KERN_WARNING_VIO
+ "console 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, int from_user,
+ const unsigned char *buf, int count)
+{
+ int ret;
+ int total = 0;
+ 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)) {
+ /* Noisy trace. Commented unless needed. */
+#if 0
+ hvlog("\n\rviotty_write: viopath NOT active for lp %d.",pi->lp);
+#endif
+ return count;
+ }
+
+ /*
+ * If the viotty_write is invoked from user space we want to do the
+ * copy_from_user() into an event buffer from the cfu buffer before
+ * internal_write() is called because internal_write may need to buffer
+ * data which will need to grab a spin_lock and we shouldn't
+ * copy_from_user() while holding a spin_lock. Should internal_write()
+ * not need to buffer data then it'll just use the event we created here
+ * rather than checking one out from vio_get_event_buffer().
+ */
+ if (from_user) {
+ struct viocharlpevent *viochar;
+ int curlen;
+ const char *curbuf = buf;
+
+ viochar = viocons_get_cfu_buffer();
+ if (viochar == NULL)
+ return -EAGAIN;
+ initDataEvent(viochar, pi->lp);
+ while (count > 0) {
+ if (count > VIOCHAR_MAX_DATA)
+ curlen = VIOCHAR_MAX_DATA;
+ else
+ curlen = count;
+ viochar->len = curlen;
+ ret = copy_from_user(viochar->data, curbuf, curlen);
+ if (ret)
+ break;
+ ret = internal_write(pi, viochar->data,
+ viochar->len, viochar);
+ total += ret;
+ if (ret != curlen)
+ break;
+ count -= curlen;
+ curbuf += curlen;
+ }
+ viocons_free_cfu_buffer(viochar);
+ } else
+ total = internal_write(pi, buf, count, NULL);
+ return total;
+}
+
+/*
+ * 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, NULL);
+}
+
+/*
+ * TTY flush_chars method
+ */
+static void viotty_flush_chars(struct tty_struct *tty)
+{
+}
+
+/*
+ * 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_room method
+ */
+static int viotty_chars_in_buffer(struct tty_struct *tty)
+{
+ return 0;
+}
+
+static void viotty_flush_buffer(struct tty_struct *tty)
+{
+}
+
+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);
+}
+
+static void viotty_throttle(struct tty_struct *tty)
+{
+}
+
+static void viotty_unthrottle(struct tty_struct *tty)
+{
+}
+
+static void viotty_set_termios(struct tty_struct *tty,
+ struct termios *old_termios)
+{
+}
+
+static void viotty_stop(struct tty_struct *tty)
+{
+}
+
+static void viotty_start(struct tty_struct *tty)
+{
+}
+
+static void viotty_hangup(struct tty_struct *tty)
+{
+}
+
+static void viotty_break(struct tty_struct *tty, int break_state)
+{
+}
+
+static void viotty_send_xchar(struct tty_struct *tty, char ch)
+{
+}
+
+static void viotty_wait_until_sent(struct tty_struct *tty, int timeout)
+{
+}
+
+/*
+ * 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(KERN_WARNING_VIO
+ "viocons: event->xRc != HvLpEvent_Rc_Good, event->xRc == (%d).\n",
+ event->xRc);
+
+ if (event->xCorrelationToken != 0) {
+ atomic_t *aptr= (atomic_t *)event->xCorrelationToken;
+ atomic_set(aptr, 1);
+ } else
+ printk(KERN_WARNING_VIO
+ "viocons: wierd...got open ack without atomic\n");
+ return;
+ }
+
+ /* This had better require an ack, otherwise complain */
+ if (event->xFlags.xAckInd != HvLpEvent_AckInd_DoAck) {
+ printk(KERN_WARNING_VIO
+ "console: 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(KERN_WARNING_VIO
+ "viocons: console open rejected : bad virtual tty.\n");
+ else if (reject == 2)
+ printk(KERN_WARNING_VIO
+ "viocons: console 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(KERN_WARNING_VIO "viocons: 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(KERN_INFO_VIO
+ "console close from %d\n", event->xSourceLp);
+ } else
+ printk(KERN_WARNING_VIO
+ "console 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(KERN_INFO_VIO
+ "console window resized to %d: %d: %d: %d\n",
+ cevent->data[1], cevent->data[2],
+ cevent->data[3], cevent->data[4]);
+ else
+ printk(KERN_WARNING_VIO "console 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(KERN_WARNING_VIO
+ "console 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(KERN_WARNING_VIO "no tty for virtual device %d\n", port);
+ return;
+ }
+
+ if (tty->magic != TTY_MAGIC) {
+ spin_unlock_irqrestore(&consolelock, flags);
+ printk(KERN_WARNING_VIO "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(KERN_WARNING_VIO
+ "console 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(KERN_WARNING_VIO
+ "viocons: 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,
+ .flush_chars = viotty_flush_chars,
+ .write_room = viotty_write_room,
+ .chars_in_buffer = viotty_chars_in_buffer,
+ .flush_buffer = viotty_flush_buffer,
+ .ioctl = viotty_ioctl,
+ .throttle = viotty_throttle,
+ .unthrottle = viotty_unthrottle,
+ .set_termios = viotty_set_termios,
+ .stop = viotty_stop,
+ .start = viotty_start,
+ .hangup = viotty_hangup,
+ .break_ctl = viotty_break,
+ .send_xchar = viotty_send_xchar,
+ .wait_until_sent = viotty_wait_until_sent,
+};
+
+static int __init viocons_init2(void)
+{
+ atomic_t wait_flag;
+ int rc;
+
+ /* Now open to the primary LP */
+ printk(KERN_INFO_VIO "console open path to primary\n");
+ /* +2 for fudge */
+ rc = viopath_open(HvLpConfig_getPrimaryLpIndex(),
+ viomajorsubtype_chario, VIOCHAR_WINDOW + 2);
+ if (rc)
+ printk(KERN_WARNING_VIO "console 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(KERN_INFO_VIO "console open path to hosting (%d)\n",
+ viopath_hostLp);
+ rc = viopath_open(viopath_hostLp, viomajorsubtype_chario,
+ VIOCHAR_WINDOW + 2); /* +2 for fudge */
+ if (rc)
+ printk(KERN_WARNING_VIO
+ "console error opening to partition %d: %d\n",
+ viopath_hostLp, rc);
+ }
+
+ if (vio_setHandler(viomajorsubtype_chario, vioHandleCharEvent) < 0)
+ printk(KERN_WARNING_VIO
+ "Error seting handler for console events!\n");
+
+ printk(KERN_INFO_VIO "console major number is %d\n", TTY_MAJOR);
+
+ /* 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(KERN_INFO_VIO
+ "opening console to 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(KERN_INFO_VIO "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->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);
+
+ viottyS_driver = alloc_tty_driver(VTTY_PORTS);
+ viottyS_driver->owner = THIS_MODULE;
+ viottyS_driver->driver_name = "vioconsole";
+ viottyS_driver->devfs_name = "tts/";
+ viottyS_driver->name = "ttyS";
+ viottyS_driver->major = TTY_MAJOR;
+ viottyS_driver->minor_start = VIOTTY_SERIAL_START;
+ viottyS_driver->type = TTY_DRIVER_TYPE_SERIAL;
+ viottyS_driver->subtype = 1;
+ viottyS_driver->init_termios = tty_std_termios;
+ viottyS_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
+ tty_set_operations(viottyS_driver, &serial_ops);
+
+ if (tty_register_driver(viotty_driver)) {
+ printk(KERN_WARNING_VIO "Couldn't register console driver\n");
+ put_tty_driver(viotty_driver);
+ viotty_driver = NULL;
+ }
+
+ if (tty_register_driver(viottyS_driver)) {
+ printk(KERN_WARNING_VIO "Couldn't register console S driver\n");
+ put_tty_driver(viottyS_driver);
+ viottyS_driver = NULL;
+ }
+
+ viocons_init_cfu_buffer();
+
+ unregister_console(&viocons_early);
+ register_console(&viocons);
+
+ return 0;
+}
+
+static int __init viocons_init(void)
+{
+ int i;
+
+ printk(KERN_INFO_VIO "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);
projects / history.git / commitdiff