mirror of
https://github.com/torvalds/linux.git
synced 2024-12-30 06:41:43 +00:00
94c8f9f974
Only initialise viocons on legacy iSeries. Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au> Signed-off-by: Paul Mackerras <paulus@samba.org>
1168 lines
30 KiB
C
1168 lines
30 KiB
C
/* -*- 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/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/firmware.h>
|
|
#include <asm/iseries/vio.h>
|
|
#include <asm/iseries/hv_lp_event.h>
|
|
#include <asm/iseries/hv_call_event.h>
|
|
#include <asm/iseries/hv_lp_config.h>
|
|
#include <asm/iseries/hv_call.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);
|
|
|
|
static int vio_sysrq_pressed;
|
|
|
|
#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 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);
|
|
}
|
|
|
|
static 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)
|
|
{
|
|
struct HvLpEvent *hev = &viochar->event;
|
|
|
|
memset(viochar, 0, sizeof(struct viocharlpevent));
|
|
|
|
hev->flags = HV_LP_EVENT_VALID | HV_LP_EVENT_DEFERRED_ACK |
|
|
HV_LP_EVENT_INT;
|
|
hev->xType = HvLpEvent_Type_VirtualIo;
|
|
hev->xSubtype = viomajorsubtype_chario | viochardata;
|
|
hev->xSourceLp = HvLpConfig_getLpIndex();
|
|
hev->xTargetLp = lp;
|
|
hev->xSizeMinus1 = sizeof(struct viocharlpevent);
|
|
hev->xSourceInstanceId = viopath_sourceinst(lp);
|
|
hev->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 (hvlpevent_is_ack(event)) {
|
|
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 (!hvlpevent_need_ack(event)) {
|
|
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 (hvlpevent_is_int(event)) {
|
|
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;
|
|
int num_pushed;
|
|
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.
|
|
*/
|
|
num_pushed = 0;
|
|
for (index = 0; index < cevent->len; index++) {
|
|
/*
|
|
* Will be optimized away if !CONFIG_MAGIC_SYSRQ:
|
|
*/
|
|
if (sysrq_on()) {
|
|
/* 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], tty);
|
|
vio_sysrq_pressed = 0;
|
|
/*
|
|
* continue because we don't want to add
|
|
* the sysrq sequence into the data string.
|
|
*/
|
|
continue;
|
|
}
|
|
}
|
|
/*
|
|
* 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_insert_flip_char(tty, cevent->data[index], TTY_NORMAL) == 0) {
|
|
printk(VIOCONS_KERN_WARN "input buffer overflow!\n");
|
|
break;
|
|
}
|
|
num_pushed++;
|
|
}
|
|
|
|
if (num_pushed)
|
|
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 (hvlpevent_is_int(event) && hvlpevent_need_ack(event)) {
|
|
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 const 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;
|
|
|
|
if (!firmware_has_feature(FW_FEATURE_ISERIES))
|
|
return -ENODEV;
|
|
|
|
/* +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->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;
|
|
|
|
if (!firmware_has_feature(FW_FEATURE_ISERIES))
|
|
return -ENODEV;
|
|
|
|
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);
|
|
add_preferred_console("viocons", 0, NULL);
|
|
register_console(&viocons_early);
|
|
return 0;
|
|
}
|
|
|
|
console_initcall(viocons_init);
|
|
module_init(viocons_init2);
|