![Jörn Engel](/assets/img/avatar_default.png)
Signed-off-by: Jörn Engel <joern@wohnheim.fh-wedel.de> Signed-off-by: Adrian Bunk <bunk@stusta.de>
471 lines
13 KiB
C
471 lines
13 KiB
C
/*
|
|
* drivers/s390/char/sclp_rw.c
|
|
* driver: reading from and writing to system console on S/390 via SCLP
|
|
*
|
|
* S390 version
|
|
* Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
|
|
* Author(s): Martin Peschke <mpeschke@de.ibm.com>
|
|
* Martin Schwidefsky <schwidefsky@de.ibm.com>
|
|
*/
|
|
|
|
#include <linux/kmod.h>
|
|
#include <linux/types.h>
|
|
#include <linux/err.h>
|
|
#include <linux/string.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/ctype.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include "sclp.h"
|
|
#include "sclp_rw.h"
|
|
|
|
#define SCLP_RW_PRINT_HEADER "sclp low level driver: "
|
|
|
|
/*
|
|
* The room for the SCCB (only for writing) is not equal to a pages size
|
|
* (as it is specified as the maximum size in the the SCLP documentation)
|
|
* because of the additional data structure described above.
|
|
*/
|
|
#define MAX_SCCB_ROOM (PAGE_SIZE - sizeof(struct sclp_buffer))
|
|
|
|
/* Event type structure for write message and write priority message */
|
|
static struct sclp_register sclp_rw_event = {
|
|
.send_mask = EvTyp_Msg_Mask | EvTyp_PMsgCmd_Mask
|
|
};
|
|
|
|
/*
|
|
* Setup a sclp write buffer. Gets a page as input (4K) and returns
|
|
* a pointer to a struct sclp_buffer structure that is located at the
|
|
* end of the input page. This reduces the buffer space by a few
|
|
* bytes but simplifies things.
|
|
*/
|
|
struct sclp_buffer *
|
|
sclp_make_buffer(void *page, unsigned short columns, unsigned short htab)
|
|
{
|
|
struct sclp_buffer *buffer;
|
|
struct write_sccb *sccb;
|
|
|
|
sccb = (struct write_sccb *) page;
|
|
/*
|
|
* We keep the struct sclp_buffer structure at the end
|
|
* of the sccb page.
|
|
*/
|
|
buffer = ((struct sclp_buffer *) ((addr_t) sccb + PAGE_SIZE)) - 1;
|
|
buffer->sccb = sccb;
|
|
buffer->retry_count = 0;
|
|
buffer->mto_number = 0;
|
|
buffer->mto_char_sum = 0;
|
|
buffer->current_line = NULL;
|
|
buffer->current_length = 0;
|
|
buffer->columns = columns;
|
|
buffer->htab = htab;
|
|
|
|
/* initialize sccb */
|
|
memset(sccb, 0, sizeof(struct write_sccb));
|
|
sccb->header.length = sizeof(struct write_sccb);
|
|
sccb->msg_buf.header.length = sizeof(struct msg_buf);
|
|
sccb->msg_buf.header.type = EvTyp_Msg;
|
|
sccb->msg_buf.mdb.header.length = sizeof(struct mdb);
|
|
sccb->msg_buf.mdb.header.type = 1;
|
|
sccb->msg_buf.mdb.header.tag = 0xD4C4C240; /* ebcdic "MDB " */
|
|
sccb->msg_buf.mdb.header.revision_code = 1;
|
|
sccb->msg_buf.mdb.go.length = sizeof(struct go);
|
|
sccb->msg_buf.mdb.go.type = 1;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/*
|
|
* Return a pointer to the orignal page that has been used to create
|
|
* the buffer.
|
|
*/
|
|
void *
|
|
sclp_unmake_buffer(struct sclp_buffer *buffer)
|
|
{
|
|
return buffer->sccb;
|
|
}
|
|
|
|
/*
|
|
* Initialize a new Message Text Object (MTO) at the end of the provided buffer
|
|
* with enough room for max_len characters. Return 0 on success.
|
|
*/
|
|
static int
|
|
sclp_initialize_mto(struct sclp_buffer *buffer, int max_len)
|
|
{
|
|
struct write_sccb *sccb;
|
|
struct mto *mto;
|
|
int mto_size;
|
|
|
|
/* max size of new Message Text Object including message text */
|
|
mto_size = sizeof(struct mto) + max_len;
|
|
|
|
/* check if current buffer sccb can contain the mto */
|
|
sccb = buffer->sccb;
|
|
if ((MAX_SCCB_ROOM - sccb->header.length) < mto_size)
|
|
return -ENOMEM;
|
|
|
|
/* find address of new message text object */
|
|
mto = (struct mto *)(((addr_t) sccb) + sccb->header.length);
|
|
|
|
/*
|
|
* fill the new Message-Text Object,
|
|
* starting behind the former last byte of the SCCB
|
|
*/
|
|
memset(mto, 0, sizeof(struct mto));
|
|
mto->length = sizeof(struct mto);
|
|
mto->type = 4; /* message text object */
|
|
mto->line_type_flags = LnTpFlgs_EndText; /* end text */
|
|
|
|
/* set pointer to first byte after struct mto. */
|
|
buffer->current_line = (char *) (mto + 1);
|
|
buffer->current_length = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Finalize MTO initialized by sclp_initialize_mto(), updating the sizes of
|
|
* MTO, enclosing MDB, event buffer and SCCB.
|
|
*/
|
|
static void
|
|
sclp_finalize_mto(struct sclp_buffer *buffer)
|
|
{
|
|
struct write_sccb *sccb;
|
|
struct mto *mto;
|
|
int str_len, mto_size;
|
|
|
|
str_len = buffer->current_length;
|
|
buffer->current_line = NULL;
|
|
buffer->current_length = 0;
|
|
|
|
/* real size of new Message Text Object including message text */
|
|
mto_size = sizeof(struct mto) + str_len;
|
|
|
|
/* find address of new message text object */
|
|
sccb = buffer->sccb;
|
|
mto = (struct mto *)(((addr_t) sccb) + sccb->header.length);
|
|
|
|
/* set size of message text object */
|
|
mto->length = mto_size;
|
|
|
|
/*
|
|
* update values of sizes
|
|
* (SCCB, Event(Message) Buffer, Message Data Block)
|
|
*/
|
|
sccb->header.length += mto_size;
|
|
sccb->msg_buf.header.length += mto_size;
|
|
sccb->msg_buf.mdb.header.length += mto_size;
|
|
|
|
/*
|
|
* count number of buffered messages (= number of Message Text
|
|
* Objects) and number of buffered characters
|
|
* for the SCCB currently used for buffering and at all
|
|
*/
|
|
buffer->mto_number++;
|
|
buffer->mto_char_sum += str_len;
|
|
}
|
|
|
|
/*
|
|
* processing of a message including escape characters,
|
|
* returns number of characters written to the output sccb
|
|
* ("processed" means that is not guaranteed that the character have already
|
|
* been sent to the SCLP but that it will be done at least next time the SCLP
|
|
* is not busy)
|
|
*/
|
|
int
|
|
sclp_write(struct sclp_buffer *buffer, const unsigned char *msg, int count)
|
|
{
|
|
int spaces, i_msg;
|
|
int rc;
|
|
|
|
/*
|
|
* parse msg for escape sequences (\t,\v ...) and put formated
|
|
* msg into an mto (created by sclp_initialize_mto).
|
|
*
|
|
* We have to do this work ourselfs because there is no support for
|
|
* these characters on the native machine and only partial support
|
|
* under VM (Why does VM interpret \n but the native machine doesn't ?)
|
|
*
|
|
* Depending on i/o-control setting the message is always written
|
|
* immediately or we wait for a final new line maybe coming with the
|
|
* next message. Besides we avoid a buffer overrun by writing its
|
|
* content.
|
|
*
|
|
* RESTRICTIONS:
|
|
*
|
|
* \r and \b work within one line because we are not able to modify
|
|
* previous output that have already been accepted by the SCLP.
|
|
*
|
|
* \t combined with following \r is not correctly represented because
|
|
* \t is expanded to some spaces but \r does not know about a
|
|
* previous \t and decreases the current position by one column.
|
|
* This is in order to a slim and quick implementation.
|
|
*/
|
|
for (i_msg = 0; i_msg < count; i_msg++) {
|
|
switch (msg[i_msg]) {
|
|
case '\n': /* new line, line feed (ASCII) */
|
|
/* check if new mto needs to be created */
|
|
if (buffer->current_line == NULL) {
|
|
rc = sclp_initialize_mto(buffer, 0);
|
|
if (rc)
|
|
return i_msg;
|
|
}
|
|
sclp_finalize_mto(buffer);
|
|
break;
|
|
case '\a': /* bell, one for several times */
|
|
/* set SCLP sound alarm bit in General Object */
|
|
buffer->sccb->msg_buf.mdb.go.general_msg_flags |=
|
|
GnrlMsgFlgs_SndAlrm;
|
|
break;
|
|
case '\t': /* horizontal tabulator */
|
|
/* check if new mto needs to be created */
|
|
if (buffer->current_line == NULL) {
|
|
rc = sclp_initialize_mto(buffer,
|
|
buffer->columns);
|
|
if (rc)
|
|
return i_msg;
|
|
}
|
|
/* "go to (next htab-boundary + 1, same line)" */
|
|
do {
|
|
if (buffer->current_length >= buffer->columns)
|
|
break;
|
|
/* ok, add a blank */
|
|
*buffer->current_line++ = 0x40;
|
|
buffer->current_length++;
|
|
} while (buffer->current_length % buffer->htab);
|
|
break;
|
|
case '\f': /* form feed */
|
|
case '\v': /* vertical tabulator */
|
|
/* "go to (actual column, actual line + 1)" */
|
|
/* = new line, leading spaces */
|
|
if (buffer->current_line != NULL) {
|
|
spaces = buffer->current_length;
|
|
sclp_finalize_mto(buffer);
|
|
rc = sclp_initialize_mto(buffer,
|
|
buffer->columns);
|
|
if (rc)
|
|
return i_msg;
|
|
memset(buffer->current_line, 0x40, spaces);
|
|
buffer->current_line += spaces;
|
|
buffer->current_length = spaces;
|
|
} else {
|
|
/* one an empty line this is the same as \n */
|
|
rc = sclp_initialize_mto(buffer,
|
|
buffer->columns);
|
|
if (rc)
|
|
return i_msg;
|
|
sclp_finalize_mto(buffer);
|
|
}
|
|
break;
|
|
case '\b': /* backspace */
|
|
/* "go to (actual column - 1, actual line)" */
|
|
/* decrement counter indicating position, */
|
|
/* do not remove last character */
|
|
if (buffer->current_line != NULL &&
|
|
buffer->current_length > 0) {
|
|
buffer->current_length--;
|
|
buffer->current_line--;
|
|
}
|
|
break;
|
|
case 0x00: /* end of string */
|
|
/* transfer current line to SCCB */
|
|
if (buffer->current_line != NULL)
|
|
sclp_finalize_mto(buffer);
|
|
/* skip the rest of the message including the 0 byte */
|
|
i_msg = count - 1;
|
|
break;
|
|
default: /* no escape character */
|
|
/* do not output unprintable characters */
|
|
if (!isprint(msg[i_msg]))
|
|
break;
|
|
/* check if new mto needs to be created */
|
|
if (buffer->current_line == NULL) {
|
|
rc = sclp_initialize_mto(buffer,
|
|
buffer->columns);
|
|
if (rc)
|
|
return i_msg;
|
|
}
|
|
*buffer->current_line++ = sclp_ascebc(msg[i_msg]);
|
|
buffer->current_length++;
|
|
break;
|
|
}
|
|
/* check if current mto is full */
|
|
if (buffer->current_line != NULL &&
|
|
buffer->current_length >= buffer->columns)
|
|
sclp_finalize_mto(buffer);
|
|
}
|
|
|
|
/* return number of processed characters */
|
|
return i_msg;
|
|
}
|
|
|
|
/*
|
|
* Return the number of free bytes in the sccb
|
|
*/
|
|
int
|
|
sclp_buffer_space(struct sclp_buffer *buffer)
|
|
{
|
|
int count;
|
|
|
|
count = MAX_SCCB_ROOM - buffer->sccb->header.length;
|
|
if (buffer->current_line != NULL)
|
|
count -= sizeof(struct mto) + buffer->current_length;
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
* Return number of characters in buffer
|
|
*/
|
|
int
|
|
sclp_chars_in_buffer(struct sclp_buffer *buffer)
|
|
{
|
|
int count;
|
|
|
|
count = buffer->mto_char_sum;
|
|
if (buffer->current_line != NULL)
|
|
count += buffer->current_length;
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
* sets or provides some values that influence the drivers behaviour
|
|
*/
|
|
void
|
|
sclp_set_columns(struct sclp_buffer *buffer, unsigned short columns)
|
|
{
|
|
buffer->columns = columns;
|
|
if (buffer->current_line != NULL &&
|
|
buffer->current_length > buffer->columns)
|
|
sclp_finalize_mto(buffer);
|
|
}
|
|
|
|
void
|
|
sclp_set_htab(struct sclp_buffer *buffer, unsigned short htab)
|
|
{
|
|
buffer->htab = htab;
|
|
}
|
|
|
|
/*
|
|
* called by sclp_console_init and/or sclp_tty_init
|
|
*/
|
|
int
|
|
sclp_rw_init(void)
|
|
{
|
|
static int init_done = 0;
|
|
int rc;
|
|
|
|
if (init_done)
|
|
return 0;
|
|
|
|
rc = sclp_register(&sclp_rw_event);
|
|
if (rc == 0)
|
|
init_done = 1;
|
|
return rc;
|
|
}
|
|
|
|
#define SCLP_BUFFER_MAX_RETRY 1
|
|
|
|
/*
|
|
* second half of Write Event Data-function that has to be done after
|
|
* interruption indicating completion of Service Call.
|
|
*/
|
|
static void
|
|
sclp_writedata_callback(struct sclp_req *request, void *data)
|
|
{
|
|
int rc;
|
|
struct sclp_buffer *buffer;
|
|
struct write_sccb *sccb;
|
|
|
|
buffer = (struct sclp_buffer *) data;
|
|
sccb = buffer->sccb;
|
|
|
|
if (request->status == SCLP_REQ_FAILED) {
|
|
if (buffer->callback != NULL)
|
|
buffer->callback(buffer, -EIO);
|
|
return;
|
|
}
|
|
/* check SCLP response code and choose suitable action */
|
|
switch (sccb->header.response_code) {
|
|
case 0x0020 :
|
|
/* Normal completion, buffer processed, message(s) sent */
|
|
rc = 0;
|
|
break;
|
|
|
|
case 0x0340: /* Contained SCLP equipment check */
|
|
if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) {
|
|
rc = -EIO;
|
|
break;
|
|
}
|
|
/* remove processed buffers and requeue rest */
|
|
if (sclp_remove_processed((struct sccb_header *) sccb) > 0) {
|
|
/* not all buffers were processed */
|
|
sccb->header.response_code = 0x0000;
|
|
buffer->request.status = SCLP_REQ_FILLED;
|
|
rc = sclp_add_request(request);
|
|
if (rc == 0)
|
|
return;
|
|
} else
|
|
rc = 0;
|
|
break;
|
|
|
|
case 0x0040: /* SCLP equipment check */
|
|
case 0x05f0: /* Target resource in improper state */
|
|
if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) {
|
|
rc = -EIO;
|
|
break;
|
|
}
|
|
/* retry request */
|
|
sccb->header.response_code = 0x0000;
|
|
buffer->request.status = SCLP_REQ_FILLED;
|
|
rc = sclp_add_request(request);
|
|
if (rc == 0)
|
|
return;
|
|
break;
|
|
default:
|
|
if (sccb->header.response_code == 0x71f0)
|
|
rc = -ENOMEM;
|
|
else
|
|
rc = -EINVAL;
|
|
break;
|
|
}
|
|
if (buffer->callback != NULL)
|
|
buffer->callback(buffer, rc);
|
|
}
|
|
|
|
/*
|
|
* Setup the request structure in the struct sclp_buffer to do SCLP Write
|
|
* Event Data and pass the request to the core SCLP loop. Return zero on
|
|
* success, non-zero otherwise.
|
|
*/
|
|
int
|
|
sclp_emit_buffer(struct sclp_buffer *buffer,
|
|
void (*callback)(struct sclp_buffer *, int))
|
|
{
|
|
struct write_sccb *sccb;
|
|
|
|
/* add current line if there is one */
|
|
if (buffer->current_line != NULL)
|
|
sclp_finalize_mto(buffer);
|
|
|
|
/* Are there messages in the output buffer ? */
|
|
if (buffer->mto_number == 0)
|
|
return -EIO;
|
|
|
|
sccb = buffer->sccb;
|
|
if (sclp_rw_event.sclp_send_mask & EvTyp_Msg_Mask)
|
|
/* Use normal write message */
|
|
sccb->msg_buf.header.type = EvTyp_Msg;
|
|
else if (sclp_rw_event.sclp_send_mask & EvTyp_PMsgCmd_Mask)
|
|
/* Use write priority message */
|
|
sccb->msg_buf.header.type = EvTyp_PMsgCmd;
|
|
else
|
|
return -ENOSYS;
|
|
buffer->request.command = SCLP_CMDW_WRITEDATA;
|
|
buffer->request.status = SCLP_REQ_FILLED;
|
|
buffer->request.callback = sclp_writedata_callback;
|
|
buffer->request.callback_data = buffer;
|
|
buffer->request.sccb = sccb;
|
|
buffer->callback = callback;
|
|
return sclp_add_request(&buffer->request);
|
|
}
|