Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

[linux-2.6/libata-dev.git] / drivers / s390 / char / tty3270.c

/*
 *    IBM/3270 Driver - tty functions.
 *
 *  Author(s):
 *    Original 3270 Code for 2.4 written by Richard Hitt (UTS Global)
 *    Rewritten for 2.5 by Martin Schwidefsky <schwidefsky@de.ibm.com>
 *      -- Copyright IBM Corp. 2003
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kdev_t.h>
#include <linux/tty.h>
#include <linux/vt_kern.h>
#include <linux/init.h>
#include <linux/console.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>

#include <linux/slab.h>
#include <linux/bootmem.h>
#include <linux/compat.h>

#include <asm/ccwdev.h>
#include <asm/cio.h>
#include <asm/ebcdic.h>
#include <asm/uaccess.h>

#include "raw3270.h"
#include "tty3270.h"
#include "keyboard.h"

#define TTY3270_CHAR_BUF_SIZE 256
#define TTY3270_OUTPUT_BUFFER_SIZE 1024
#define TTY3270_STRING_PAGES 5

struct tty_driver *tty3270_driver;
static int tty3270_max_index;

static struct raw3270_fn tty3270_fn;

struct tty3270_cell {
        unsigned char character;
        unsigned char highlight;
        unsigned char f_color;
};

struct tty3270_line {
        struct tty3270_cell *cells;
        int len;
};

#define ESCAPE_NPAR 8

/*
 * The main tty view data structure.
 * FIXME:
 * 1) describe line orientation & lines list concept against screen
 * 2) describe conversion of screen to lines
 * 3) describe line format.
 */
struct tty3270 {
        struct raw3270_view view;
        struct tty_port port;
        void **freemem_pages;           /* Array of pages used for freemem. */
        struct list_head freemem;       /* List of free memory for strings. */

        /* Output stuff. */
        struct list_head lines;         /* List of lines. */
        struct list_head update;        /* List of lines to update. */
        unsigned char wcc;              /* Write control character. */
        int nr_lines;                   /* # lines in list. */
        int nr_up;                      /* # lines up in history. */
        unsigned long update_flags;     /* Update indication bits. */
        struct string *status;          /* Lower right of display. */
        struct raw3270_request *write;  /* Single write request. */
        struct timer_list timer;        /* Output delay timer. */

        /* Current tty screen. */
        unsigned int cx, cy;            /* Current output position. */
        unsigned int highlight;         /* Blink/reverse/underscore */
        unsigned int f_color;           /* Foreground color */
        struct tty3270_line *screen;
        unsigned int n_model, n_cols, n_rows;   /* New model & size */
        struct work_struct resize_work;

        /* Input stuff. */
        struct string *prompt;          /* Output string for input area. */
        struct string *input;           /* Input string for read request. */
        struct raw3270_request *read;   /* Single read request. */
        struct raw3270_request *kreset; /* Single keyboard reset request. */
        unsigned char inattr;           /* Visible/invisible input. */
        int throttle, attn;             /* tty throttle/unthrottle. */
        struct tasklet_struct readlet;  /* Tasklet to issue read request. */
        struct kbd_data *kbd;           /* key_maps stuff. */

        /* Escape sequence parsing. */
        int esc_state, esc_ques, esc_npar;
        int esc_par[ESCAPE_NPAR];
        unsigned int saved_cx, saved_cy;
        unsigned int saved_highlight, saved_f_color;

        /* Command recalling. */
        struct list_head rcl_lines;     /* List of recallable lines. */
        struct list_head *rcl_walk;     /* Point in rcl_lines list. */
        int rcl_nr, rcl_max;            /* Number/max number of rcl_lines. */

        /* Character array for put_char/flush_chars. */
        unsigned int char_count;
        char char_buf[TTY3270_CHAR_BUF_SIZE];
};

/* tty3270->update_flags. See tty3270_update for details. */
#define TTY_UPDATE_ERASE        1       /* Use EWRITEA instead of WRITE. */
#define TTY_UPDATE_LIST         2       /* Update lines in tty3270->update. */
#define TTY_UPDATE_INPUT        4       /* Update input line. */
#define TTY_UPDATE_STATUS       8       /* Update status line. */
#define TTY_UPDATE_ALL          16      /* Recreate screen. */

static void tty3270_update(struct tty3270 *);
static void tty3270_resize_work(struct work_struct *work);

/*
 * Setup timeout for a device. On timeout trigger an update.
 */
static void tty3270_set_timer(struct tty3270 *tp, int expires)
{
        if (expires == 0)
                del_timer(&tp->timer);
        else
                mod_timer(&tp->timer, jiffies + expires);
}

/*
 * The input line are the two last lines of the screen.
 */
static void
tty3270_update_prompt(struct tty3270 *tp, char *input, int count)
{
        struct string *line;
        unsigned int off;

        line = tp->prompt;
        if (count != 0)
                line->string[5] = TF_INMDT;
        else
                line->string[5] = tp->inattr;
        if (count > tp->view.cols * 2 - 11)
                count = tp->view.cols * 2 - 11;
        memcpy(line->string + 6, input, count);
        line->string[6 + count] = TO_IC;
        /* Clear to end of input line. */
        if (count < tp->view.cols * 2 - 11) {
                line->string[7 + count] = TO_RA;
                line->string[10 + count] = 0;
                off = tp->view.cols * tp->view.rows - 9;
                raw3270_buffer_address(tp->view.dev, line->string+count+8, off);
                line->len = 11 + count;
        } else
                line->len = 7 + count;
        tp->update_flags |= TTY_UPDATE_INPUT;
}

static void
tty3270_create_prompt(struct tty3270 *tp)
{
        static const unsigned char blueprint[] =
                { TO_SBA, 0, 0, 0x6e, TO_SF, TF_INPUT,
                  /* empty input string */
                  TO_IC, TO_RA, 0, 0, 0 };
        struct string *line;
        unsigned int offset;

        line = alloc_string(&tp->freemem,
                            sizeof(blueprint) + tp->view.cols * 2 - 9);
        tp->prompt = line;
        tp->inattr = TF_INPUT;
        /* Copy blueprint to status line */
        memcpy(line->string, blueprint, sizeof(blueprint));
        line->len = sizeof(blueprint);
        /* Set output offsets. */
        offset = tp->view.cols * (tp->view.rows - 2);
        raw3270_buffer_address(tp->view.dev, line->string + 1, offset);
        offset = tp->view.cols * tp->view.rows - 9;
        raw3270_buffer_address(tp->view.dev, line->string + 8, offset);

        /* Allocate input string for reading. */
        tp->input = alloc_string(&tp->freemem, tp->view.cols * 2 - 9 + 6);
}

/*
 * The status line is the last line of the screen. It shows the string
 * "Running"/"Holding" in the lower right corner of the screen.
 */
static void
tty3270_update_status(struct tty3270 * tp)
{
        char *str;

        str = (tp->nr_up != 0) ? "History" : "Running";
        memcpy(tp->status->string + 8, str, 7);
        codepage_convert(tp->view.ascebc, tp->status->string + 8, 7);
        tp->update_flags |= TTY_UPDATE_STATUS;
}

static void
tty3270_create_status(struct tty3270 * tp)
{
        static const unsigned char blueprint[] =
                { TO_SBA, 0, 0, TO_SF, TF_LOG, TO_SA, TAT_COLOR, TAC_GREEN,
                  0, 0, 0, 0, 0, 0, 0, TO_SF, TF_LOG, TO_SA, TAT_COLOR,
                  TAC_RESET };
        struct string *line;
        unsigned int offset;

        line = alloc_string(&tp->freemem,sizeof(blueprint));
        tp->status = line;
        /* Copy blueprint to status line */
        memcpy(line->string, blueprint, sizeof(blueprint));
        /* Set address to start of status string (= last 9 characters). */
        offset = tp->view.cols * tp->view.rows - 9;
        raw3270_buffer_address(tp->view.dev, line->string + 1, offset);
}

/*
 * Set output offsets to 3270 datastream fragment of a tty string.
 * (TO_SBA offset at the start and TO_RA offset at the end of the string)
 */
static void
tty3270_update_string(struct tty3270 *tp, struct string *line, int nr)
{
        unsigned char *cp;

        raw3270_buffer_address(tp->view.dev, line->string + 1,
                               tp->view.cols * nr);
        cp = line->string + line->len - 4;
        if (*cp == TO_RA)
                raw3270_buffer_address(tp->view.dev, cp + 1,
                                       tp->view.cols * (nr + 1));
}

/*
 * Rebuild update list to print all lines.
 */
static void
tty3270_rebuild_update(struct tty3270 *tp)
{
        struct string *s, *n;
        int line, nr_up;

        /* 
         * Throw away update list and create a new one,
         * containing all lines that will fit on the screen.
         */
        list_for_each_entry_safe(s, n, &tp->update, update)
                list_del_init(&s->update);
        line = tp->view.rows - 3;
        nr_up = tp->nr_up;
        list_for_each_entry_reverse(s, &tp->lines, list) {
                if (nr_up > 0) {
                        nr_up--;
                        continue;
                }
                tty3270_update_string(tp, s, line);
                list_add(&s->update, &tp->update);
                if (--line < 0)
                        break;
        }
        tp->update_flags |= TTY_UPDATE_LIST;
}

/*
 * Alloc string for size bytes. If there is not enough room in
 * freemem, free strings until there is room.
 */
static struct string *
tty3270_alloc_string(struct tty3270 *tp, size_t size)
{
        struct string *s, *n;

        s = alloc_string(&tp->freemem, size);
        if (s)
                return s;
        list_for_each_entry_safe(s, n, &tp->lines, list) {
                BUG_ON(tp->nr_lines <= tp->view.rows - 2);
                list_del(&s->list);
                if (!list_empty(&s->update))
                        list_del(&s->update);
                tp->nr_lines--;
                if (free_string(&tp->freemem, s) >= size)
                        break;
        }
        s = alloc_string(&tp->freemem, size);
        BUG_ON(!s);
        if (tp->nr_up != 0 &&
            tp->nr_up + tp->view.rows - 2 >= tp->nr_lines) {
                tp->nr_up = tp->nr_lines - tp->view.rows + 2;
                tty3270_rebuild_update(tp);
                tty3270_update_status(tp);
        }
        return s;
}

/*
 * Add an empty line to the list.
 */
static void
tty3270_blank_line(struct tty3270 *tp)
{
        static const unsigned char blueprint[] =
                { TO_SBA, 0, 0, TO_SA, TAT_EXTHI, TAX_RESET,
                  TO_SA, TAT_COLOR, TAC_RESET, TO_RA, 0, 0, 0 };
        struct string *s;

        s = tty3270_alloc_string(tp, sizeof(blueprint));
        memcpy(s->string, blueprint, sizeof(blueprint));
        s->len = sizeof(blueprint);
        list_add_tail(&s->list, &tp->lines);
        tp->nr_lines++;
        if (tp->nr_up != 0)
                tp->nr_up++;
}

/*
 * Write request completion callback.
 */
static void
tty3270_write_callback(struct raw3270_request *rq, void *data)
{
        struct tty3270 *tp = container_of(rq->view, struct tty3270, view);

        if (rq->rc != 0) {
                /* Write wasn't successful. Refresh all. */
                tp->update_flags = TTY_UPDATE_ALL;
                tty3270_set_timer(tp, 1);
        }
        raw3270_request_reset(rq);
        xchg(&tp->write, rq);
}

/*
 * Update 3270 display.
 */
static void
tty3270_update(struct tty3270 *tp)
{
        static char invalid_sba[2] = { 0xff, 0xff };
        struct raw3270_request *wrq;
        unsigned long updated;
        struct string *s, *n;
        char *sba, *str;
        int rc, len;

        wrq = xchg(&tp->write, 0);
        if (!wrq) {
                tty3270_set_timer(tp, 1);
                return;
        }

        spin_lock(&tp->view.lock);
        updated = 0;
        if (tp->update_flags & TTY_UPDATE_ALL) {
                tty3270_rebuild_update(tp);
                tty3270_update_status(tp);
                tp->update_flags = TTY_UPDATE_ERASE | TTY_UPDATE_LIST |
                        TTY_UPDATE_INPUT | TTY_UPDATE_STATUS;
        }
        if (tp->update_flags & TTY_UPDATE_ERASE) {
                /* Use erase write alternate to erase display. */
                raw3270_request_set_cmd(wrq, TC_EWRITEA);
                updated |= TTY_UPDATE_ERASE;
        } else
                raw3270_request_set_cmd(wrq, TC_WRITE);

        raw3270_request_add_data(wrq, &tp->wcc, 1);
        tp->wcc = TW_NONE;

        /*
         * Update status line.
         */
        if (tp->update_flags & TTY_UPDATE_STATUS)
                if (raw3270_request_add_data(wrq, tp->status->string,
                                             tp->status->len) == 0)
                        updated |= TTY_UPDATE_STATUS;

        /*
         * Write input line.
         */
        if (tp->update_flags & TTY_UPDATE_INPUT)
                if (raw3270_request_add_data(wrq, tp->prompt->string,
                                             tp->prompt->len) == 0)
                        updated |= TTY_UPDATE_INPUT;

        sba = invalid_sba;
        
        if (tp->update_flags & TTY_UPDATE_LIST) {
                /* Write strings in the update list to the screen. */
                list_for_each_entry_safe(s, n, &tp->update, update) {
                        str = s->string;
                        len = s->len;
                        /*
                         * Skip TO_SBA at the start of the string if the
                         * last output position matches the start address
                         * of this line.
                         */
                        if (s->string[1] == sba[0] && s->string[2] == sba[1])
                                str += 3, len -= 3;
                        if (raw3270_request_add_data(wrq, str, len) != 0)
                                break;
                        list_del_init(&s->update);
                        sba = s->string + s->len - 3;
                }
                if (list_empty(&tp->update))
                        updated |= TTY_UPDATE_LIST;
        }
        wrq->callback = tty3270_write_callback;
        rc = raw3270_start(&tp->view, wrq);
        if (rc == 0) {
                tp->update_flags &= ~updated;
                if (tp->update_flags)
                        tty3270_set_timer(tp, 1);
        } else {
                raw3270_request_reset(wrq);
                xchg(&tp->write, wrq);
        }
        spin_unlock(&tp->view.lock);
}

/*
 * Command recalling.
 */
static void
tty3270_rcl_add(struct tty3270 *tp, char *input, int len)
{
        struct string *s;

        tp->rcl_walk = NULL;
        if (len <= 0)
                return;
        if (tp->rcl_nr >= tp->rcl_max) {
                s = list_entry(tp->rcl_lines.next, struct string, list);
                list_del(&s->list);
                free_string(&tp->freemem, s);
                tp->rcl_nr--;
        }
        s = tty3270_alloc_string(tp, len);
        memcpy(s->string, input, len);
        list_add_tail(&s->list, &tp->rcl_lines);
        tp->rcl_nr++;
}

static void
tty3270_rcl_backward(struct kbd_data *kbd)
{
        struct tty3270 *tp = container_of(kbd->port, struct tty3270, port);
        struct string *s;

        spin_lock_bh(&tp->view.lock);
        if (tp->inattr == TF_INPUT) {
                if (tp->rcl_walk && tp->rcl_walk->prev != &tp->rcl_lines)
                        tp->rcl_walk = tp->rcl_walk->prev;
                else if (!list_empty(&tp->rcl_lines))
                        tp->rcl_walk = tp->rcl_lines.prev;
                s = tp->rcl_walk ? 
                        list_entry(tp->rcl_walk, struct string, list) : NULL;
                if (tp->rcl_walk) {
                        s = list_entry(tp->rcl_walk, struct string, list);
                        tty3270_update_prompt(tp, s->string, s->len);
                } else
                        tty3270_update_prompt(tp, NULL, 0);
                tty3270_set_timer(tp, 1);
        }
        spin_unlock_bh(&tp->view.lock);
}

/*
 * Deactivate tty view.
 */
static void
tty3270_exit_tty(struct kbd_data *kbd)
{
        struct tty3270 *tp = container_of(kbd->port, struct tty3270, port);

        raw3270_deactivate_view(&tp->view);
}

/*
 * Scroll forward in history.
 */
static void
tty3270_scroll_forward(struct kbd_data *kbd)
{
        struct tty3270 *tp = container_of(kbd->port, struct tty3270, port);
        int nr_up;

        spin_lock_bh(&tp->view.lock);
        nr_up = tp->nr_up - tp->view.rows + 2;
        if (nr_up < 0)
                nr_up = 0;
        if (nr_up != tp->nr_up) {
                tp->nr_up = nr_up;
                tty3270_rebuild_update(tp);
                tty3270_update_status(tp);
                tty3270_set_timer(tp, 1);
        }
        spin_unlock_bh(&tp->view.lock);
}

/*
 * Scroll backward in history.
 */
static void
tty3270_scroll_backward(struct kbd_data *kbd)
{
        struct tty3270 *tp = container_of(kbd->port, struct tty3270, port);
        int nr_up;

        spin_lock_bh(&tp->view.lock);
        nr_up = tp->nr_up + tp->view.rows - 2;
        if (nr_up + tp->view.rows - 2 > tp->nr_lines)
                nr_up = tp->nr_lines - tp->view.rows + 2;
        if (nr_up != tp->nr_up) {
                tp->nr_up = nr_up;
                tty3270_rebuild_update(tp);
                tty3270_update_status(tp);
                tty3270_set_timer(tp, 1);
        }
        spin_unlock_bh(&tp->view.lock);
}

/*
 * Pass input line to tty.
 */
static void
tty3270_read_tasklet(struct raw3270_request *rrq)
{
        static char kreset_data = TW_KR;
        struct tty3270 *tp = container_of(rrq->view, struct tty3270, view);
        char *input;
        int len;

        spin_lock_bh(&tp->view.lock);
        /*
         * Two AID keys are special: For 0x7d (enter) the input line
         * has to be emitted to the tty and for 0x6d the screen
         * needs to be redrawn.
         */
        input = NULL;
        len = 0;
        if (tp->input->string[0] == 0x7d) {
                /* Enter: write input to tty. */
                input = tp->input->string + 6;
                len = tp->input->len - 6 - rrq->rescnt;
                if (tp->inattr != TF_INPUTN)
                        tty3270_rcl_add(tp, input, len);
                if (tp->nr_up > 0) {
                        tp->nr_up = 0;
                        tty3270_rebuild_update(tp);
                        tty3270_update_status(tp);
                }
                /* Clear input area. */
                tty3270_update_prompt(tp, NULL, 0);
                tty3270_set_timer(tp, 1);
        } else if (tp->input->string[0] == 0x6d) {
                /* Display has been cleared. Redraw. */
                tp->update_flags = TTY_UPDATE_ALL;
                tty3270_set_timer(tp, 1);
        }
        spin_unlock_bh(&tp->view.lock);

        /* Start keyboard reset command. */
        raw3270_request_reset(tp->kreset);
        raw3270_request_set_cmd(tp->kreset, TC_WRITE);
        raw3270_request_add_data(tp->kreset, &kreset_data, 1);
        raw3270_start(&tp->view, tp->kreset);

        while (len-- > 0)
                kbd_keycode(tp->kbd, *input++);
        /* Emit keycode for AID byte. */
        kbd_keycode(tp->kbd, 256 + tp->input->string[0]);

        raw3270_request_reset(rrq);
        xchg(&tp->read, rrq);
        raw3270_put_view(&tp->view);
}

/*
 * Read request completion callback.
 */
static void
tty3270_read_callback(struct raw3270_request *rq, void *data)
{
        struct tty3270 *tp = container_of(rq->view, struct tty3270, view);
        raw3270_get_view(rq->view);
        /* Schedule tasklet to pass input to tty. */
        tasklet_schedule(&tp->readlet);
}

/*
 * Issue a read request. Call with device lock.
 */
static void
tty3270_issue_read(struct tty3270 *tp, int lock)
{
        struct raw3270_request *rrq;
        int rc;

        rrq = xchg(&tp->read, 0);
        if (!rrq)
                /* Read already scheduled. */
                return;
        rrq->callback = tty3270_read_callback;
        rrq->callback_data = tp;
        raw3270_request_set_cmd(rrq, TC_READMOD);
        raw3270_request_set_data(rrq, tp->input->string, tp->input->len);
        /* Issue the read modified request. */
        if (lock) {
                rc = raw3270_start(&tp->view, rrq);
        } else
                rc = raw3270_start_irq(&tp->view, rrq);
        if (rc) {
                raw3270_request_reset(rrq);
                xchg(&tp->read, rrq);
        }
}

/*
 * Switch to the tty view.
 */
static int
tty3270_activate(struct raw3270_view *view)
{
        struct tty3270 *tp = container_of(view, struct tty3270, view);

        tp->update_flags = TTY_UPDATE_ALL;
        tty3270_set_timer(tp, 1);
        return 0;
}

static void
tty3270_deactivate(struct raw3270_view *view)
{
        struct tty3270 *tp = container_of(view, struct tty3270, view);

        del_timer(&tp->timer);
}

static int
tty3270_irq(struct tty3270 *tp, struct raw3270_request *rq, struct irb *irb)
{
        /* Handle ATTN. Schedule tasklet to read aid. */
        if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
                if (!tp->throttle)
                        tty3270_issue_read(tp, 0);
                else
                        tp->attn = 1;
        }

        if (rq) {
                if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)
                        rq->rc = -EIO;
                else
                        /* Normal end. Copy residual count. */
                        rq->rescnt = irb->scsw.cmd.count;
        }
        return RAW3270_IO_DONE;
}

/*
 * Allocate tty3270 structure.
 */
static struct tty3270 *
tty3270_alloc_view(void)
{
        struct tty3270 *tp;
        int pages;

        tp = kzalloc(sizeof(struct tty3270), GFP_KERNEL);
        if (!tp)
                goto out_err;
        tp->freemem_pages =
                kmalloc(sizeof(void *) * TTY3270_STRING_PAGES, GFP_KERNEL);
        if (!tp->freemem_pages)
                goto out_tp;
        INIT_LIST_HEAD(&tp->freemem);
        INIT_LIST_HEAD(&tp->lines);
        INIT_LIST_HEAD(&tp->update);
        INIT_LIST_HEAD(&tp->rcl_lines);
        tp->rcl_max = 20;

        for (pages = 0; pages < TTY3270_STRING_PAGES; pages++) {
                tp->freemem_pages[pages] = (void *)
                        __get_free_pages(GFP_KERNEL|GFP_DMA, 0);
                if (!tp->freemem_pages[pages])
                        goto out_pages;
                add_string_memory(&tp->freemem,
                                  tp->freemem_pages[pages], PAGE_SIZE);
        }
        tp->write = raw3270_request_alloc(TTY3270_OUTPUT_BUFFER_SIZE);
        if (IS_ERR(tp->write))
                goto out_pages;
        tp->read = raw3270_request_alloc(0);
        if (IS_ERR(tp->read))
                goto out_write;
        tp->kreset = raw3270_request_alloc(1);
        if (IS_ERR(tp->kreset))
                goto out_read;
        tp->kbd = kbd_alloc();
        if (!tp->kbd)
                goto out_reset;

        tty_port_init(&tp->port);
        setup_timer(&tp->timer, (void (*)(unsigned long)) tty3270_update,
                    (unsigned long) tp);
        tasklet_init(&tp->readlet,
                     (void (*)(unsigned long)) tty3270_read_tasklet,
                     (unsigned long) tp->read);
        INIT_WORK(&tp->resize_work, tty3270_resize_work);

        return tp;

out_reset:
        raw3270_request_free(tp->kreset);
out_read:
        raw3270_request_free(tp->read);
out_write:
        raw3270_request_free(tp->write);
out_pages:
        while (pages--)
                free_pages((unsigned long) tp->freemem_pages[pages], 0);
        kfree(tp->freemem_pages);
        tty_port_destroy(&tp->port);
out_tp:
        kfree(tp);
out_err:
        return ERR_PTR(-ENOMEM);
}

/*
 * Free tty3270 structure.
 */
static void
tty3270_free_view(struct tty3270 *tp)
{
        int pages;

        del_timer_sync(&tp->timer);
        kbd_free(tp->kbd);
        raw3270_request_free(tp->kreset);
        raw3270_request_free(tp->read);
        raw3270_request_free(tp->write);
        for (pages = 0; pages < TTY3270_STRING_PAGES; pages++)
                free_pages((unsigned long) tp->freemem_pages[pages], 0);
        kfree(tp->freemem_pages);
        tty_port_destroy(&tp->port);
        kfree(tp);
}

/*
 * Allocate tty3270 screen.
 */
static struct tty3270_line *
tty3270_alloc_screen(unsigned int rows, unsigned int cols)
{
        struct tty3270_line *screen;
        unsigned long size;
        int lines;

        size = sizeof(struct tty3270_line) * (rows - 2);
        screen = kzalloc(size, GFP_KERNEL);
        if (!screen)
                goto out_err;
        for (lines = 0; lines < rows - 2; lines++) {
                size = sizeof(struct tty3270_cell) * cols;
                screen[lines].cells = kzalloc(size, GFP_KERNEL);
                if (!screen[lines].cells)
                        goto out_screen;
        }
        return screen;
out_screen:
        while (lines--)
                kfree(screen[lines].cells);
        kfree(screen);
out_err:
        return ERR_PTR(-ENOMEM);
}

/*
 * Free tty3270 screen.
 */
static void
tty3270_free_screen(struct tty3270_line *screen, unsigned int rows)
{
        int lines;

        for (lines = 0; lines < rows - 2; lines++)
                kfree(screen[lines].cells);
        kfree(screen);
}

/*
 * Resize tty3270 screen
 */
static void tty3270_resize_work(struct work_struct *work)
{
        struct tty3270 *tp = container_of(work, struct tty3270, resize_work);
        struct tty3270_line *screen, *oscreen;
        struct tty_struct *tty;
        unsigned int orows;
        struct winsize ws;

        screen = tty3270_alloc_screen(tp->n_rows, tp->n_cols);
        if (!screen)
                return;
        /* Switch to new output size */
        spin_lock_bh(&tp->view.lock);
        oscreen = tp->screen;
        orows = tp->view.rows;
        tp->view.model = tp->n_model;
        tp->view.rows = tp->n_rows;
        tp->view.cols = tp->n_cols;
        tp->screen = screen;
        free_string(&tp->freemem, tp->prompt);
        free_string(&tp->freemem, tp->status);
        tty3270_create_prompt(tp);
        tty3270_create_status(tp);
        tp->nr_up = 0;
        while (tp->nr_lines < tp->view.rows - 2)
                tty3270_blank_line(tp);
        tp->update_flags = TTY_UPDATE_ALL;
        spin_unlock_bh(&tp->view.lock);
        tty3270_free_screen(oscreen, orows);
        tty3270_set_timer(tp, 1);
        /* Informat tty layer about new size */
        tty = tty_port_tty_get(&tp->port);
        if (!tty)
                return;
        ws.ws_row = tp->view.rows - 2;
        ws.ws_col = tp->view.cols;
        tty_do_resize(tty, &ws);
}

static void
tty3270_resize(struct raw3270_view *view, int model, int rows, int cols)
{
        struct tty3270 *tp = container_of(view, struct tty3270, view);

        tp->n_model = model;
        tp->n_rows = rows;
        tp->n_cols = cols;
        schedule_work(&tp->resize_work);
}

/*
 * Unlink tty3270 data structure from tty.
 */
static void
tty3270_release(struct raw3270_view *view)
{
        struct tty3270 *tp = container_of(view, struct tty3270, view);
        struct tty_struct *tty = tty_port_tty_get(&tp->port);

        if (tty) {
                tty->driver_data = NULL;
                tty_port_tty_set(&tp->port, NULL);
                tty_hangup(tty);
                raw3270_put_view(&tp->view);
                tty_kref_put(tty);
        }
}

/*
 * Free tty3270 data structure
 */
static void
tty3270_free(struct raw3270_view *view)
{
        struct tty3270 *tp = container_of(view, struct tty3270, view);

        tty3270_free_screen(tp->screen, tp->view.rows);
        tty3270_free_view(tp);
}

/*
 * Delayed freeing of tty3270 views.
 */
static void
tty3270_del_views(void)
{
        int i;

        for (i = RAW3270_FIRSTMINOR; i <= tty3270_max_index; i++) {
                struct raw3270_view *view = raw3270_find_view(&tty3270_fn, i);
                if (!IS_ERR(view))
                        raw3270_del_view(view);
        }
}

static struct raw3270_fn tty3270_fn = {
        .activate = tty3270_activate,
        .deactivate = tty3270_deactivate,
        .intv = (void *) tty3270_irq,
        .release = tty3270_release,
        .free = tty3270_free,
        .resize = tty3270_resize
};

/*
 * This routine is called whenever a 3270 tty is opened first time.
 */
static int tty3270_install(struct tty_driver *driver, struct tty_struct *tty)
{
        struct raw3270_view *view;
        struct tty3270 *tp;
        int i, rc;

        /* Check if the tty3270 is already there. */
        view = raw3270_find_view(&tty3270_fn, tty->index);
        if (!IS_ERR(view)) {
                tp = container_of(view, struct tty3270, view);
                tty->driver_data = tp;
                tty->winsize.ws_row = tp->view.rows - 2;
                tty->winsize.ws_col = tp->view.cols;
                tp->port.low_latency = 0;
                /* why to reassign? */
                tty_port_tty_set(&tp->port, tty);
                tp->inattr = TF_INPUT;
                return tty_port_install(&tp->port, driver, tty);
        }
        if (tty3270_max_index < tty->index)
                tty3270_max_index = tty->index;

        /* Allocate tty3270 structure on first open. */
        tp = tty3270_alloc_view();
        if (IS_ERR(tp))
                return PTR_ERR(tp);

        rc = raw3270_add_view(&tp->view, &tty3270_fn, tty->index);
        if (rc) {
                tty3270_free_view(tp);
                return rc;
        }

        tp->screen = tty3270_alloc_screen(tp->view.cols, tp->view.rows);
        if (IS_ERR(tp->screen)) {
                rc = PTR_ERR(tp->screen);
                raw3270_put_view(&tp->view);
                raw3270_del_view(&tp->view);
                tty3270_free_view(tp);
                return rc;
        }

        tty_port_tty_set(&tp->port, tty);
        tp->port.low_latency = 0;
        tty->winsize.ws_row = tp->view.rows - 2;
        tty->winsize.ws_col = tp->view.cols;

        tty3270_create_prompt(tp);
        tty3270_create_status(tp);
        tty3270_update_status(tp);

        /* Create blank line for every line in the tty output area. */
        for (i = 0; i < tp->view.rows - 2; i++)
                tty3270_blank_line(tp);

        tp->kbd->port = &tp->port;
        tp->kbd->fn_handler[KVAL(K_INCRCONSOLE)] = tty3270_exit_tty;
        tp->kbd->fn_handler[KVAL(K_SCROLLBACK)] = tty3270_scroll_backward;
        tp->kbd->fn_handler[KVAL(K_SCROLLFORW)] = tty3270_scroll_forward;
        tp->kbd->fn_handler[KVAL(K_CONS)] = tty3270_rcl_backward;
        kbd_ascebc(tp->kbd, tp->view.ascebc);

        raw3270_activate_view(&tp->view);

        rc = tty_port_install(&tp->port, driver, tty);
        if (rc) {
                raw3270_put_view(&tp->view);
                return rc;
        }

        tty->driver_data = tp;

        return 0;
}

/*
 * This routine is called whenever a 3270 tty is opened.
 */
static int
tty3270_open(struct tty_struct *tty, struct file *filp)
{
        struct tty3270 *tp = tty->driver_data;
        struct tty_port *port = &tp->port;

        port->count++;
        tty_port_tty_set(port, tty);
        return 0;
}

/*
 * This routine is called when the 3270 tty is closed. We wait
 * for the remaining request to be completed. Then we clean up.
 */
static void
tty3270_close(struct tty_struct *tty, struct file * filp)
{
        struct tty3270 *tp = tty->driver_data;

        if (tty->count > 1)
                return;
        if (tp) {
                tty->driver_data = NULL;
                tty_port_tty_set(&tp->port, NULL);
        }
}

static void tty3270_cleanup(struct tty_struct *tty)
{
        struct tty3270 *tp = tty->driver_data;

        if (tp)
                raw3270_put_view(&tp->view);
}

/*
 * We always have room.
 */
static int
tty3270_write_room(struct tty_struct *tty)
{
        return INT_MAX;
}

/*
 * Insert character into the screen at the current position with the
 * current color and highlight. This function does NOT do cursor movement.
 */
static void tty3270_put_character(struct tty3270 *tp, char ch)
{
        struct tty3270_line *line;
        struct tty3270_cell *cell;

        line = tp->screen + tp->cy;
        if (line->len <= tp->cx) {
                while (line->len < tp->cx) {
                        cell = line->cells + line->len;
                        cell->character = tp->view.ascebc[' '];
                        cell->highlight = tp->highlight;
                        cell->f_color = tp->f_color;
                        line->len++;
                }
                line->len++;
        }
        cell = line->cells + tp->cx;
        cell->character = tp->view.ascebc[(unsigned int) ch];
        cell->highlight = tp->highlight;
        cell->f_color = tp->f_color;
}

/*
 * Convert a tty3270_line to a 3270 data fragment usable for output.
 */
static void
tty3270_convert_line(struct tty3270 *tp, int line_nr)
{
        struct tty3270_line *line;
        struct tty3270_cell *cell;
        struct string *s, *n;
        unsigned char highlight;
        unsigned char f_color;
        char *cp;
        int flen, i;

        /* Determine how long the fragment will be. */
        flen = 3;               /* Prefix (TO_SBA). */
        line = tp->screen + line_nr;
        flen += line->len;
        highlight = TAX_RESET;
        f_color = TAC_RESET;
        for (i = 0, cell = line->cells; i < line->len; i++, cell++) {
                if (cell->highlight != highlight) {
                        flen += 3;      /* TO_SA to switch highlight. */
                        highlight = cell->highlight;
                }
                if (cell->f_color != f_color) {
                        flen += 3;      /* TO_SA to switch color. */
                        f_color = cell->f_color;
                }
        }
        if (highlight != TAX_RESET)
                flen += 3;      /* TO_SA to reset hightlight. */
        if (f_color != TAC_RESET)
                flen += 3;      /* TO_SA to reset color. */
        if (line->len < tp->view.cols)
                flen += 4;      /* Postfix (TO_RA). */

        /* Find the line in the list. */
        i = tp->view.rows - 2 - line_nr;
        list_for_each_entry_reverse(s, &tp->lines, list)
                if (--i <= 0)
                        break;
        /*
         * Check if the line needs to get reallocated.
         */
        if (s->len != flen) {
                /* Reallocate string. */
                n = tty3270_alloc_string(tp, flen);
                list_add(&n->list, &s->list);
                list_del_init(&s->list);
                if (!list_empty(&s->update))
                        list_del_init(&s->update);
                free_string(&tp->freemem, s);
                s = n;
        }

        /* Write 3270 data fragment. */
        cp = s->string;
        *cp++ = TO_SBA;
        *cp++ = 0;
        *cp++ = 0;

        highlight = TAX_RESET;
        f_color = TAC_RESET;
        for (i = 0, cell = line->cells; i < line->len; i++, cell++) {
                if (cell->highlight != highlight) {
                        *cp++ = TO_SA;
                        *cp++ = TAT_EXTHI;
                        *cp++ = cell->highlight;
                        highlight = cell->highlight;
                }
                if (cell->f_color != f_color) {
                        *cp++ = TO_SA;
                        *cp++ = TAT_COLOR;
                        *cp++ = cell->f_color;
                        f_color = cell->f_color;
                }
                *cp++ = cell->character;
        }
        if (highlight != TAX_RESET) {
                *cp++ = TO_SA;
                *cp++ = TAT_EXTHI;
                *cp++ = TAX_RESET;
        }
        if (f_color != TAC_RESET) {
                *cp++ = TO_SA;
                *cp++ = TAT_COLOR;
                *cp++ = TAC_RESET;
        }
        if (line->len < tp->view.cols) {
                *cp++ = TO_RA;
                *cp++ = 0;
                *cp++ = 0;
                *cp++ = 0;
        }

        if (tp->nr_up + line_nr < tp->view.rows - 2) {
                /* Line is currently visible on screen. */
                tty3270_update_string(tp, s, line_nr);
                /* Add line to update list. */
                if (list_empty(&s->update)) {
                        list_add_tail(&s->update, &tp->update);
                        tp->update_flags |= TTY_UPDATE_LIST;
                }
        }
}

/*
 * Do carriage return.
 */
static void
tty3270_cr(struct tty3270 *tp)
{
        tp->cx = 0;
}

/*
 * Do line feed.
 */
static void
tty3270_lf(struct tty3270 *tp)
{
        struct tty3270_line temp;
        int i;

        tty3270_convert_line(tp, tp->cy);
        if (tp->cy < tp->view.rows - 3) {
                tp->cy++;
                return;
        }
        /* Last line just filled up. Add new, blank line. */
        tty3270_blank_line(tp);
        temp = tp->screen[0];
        temp.len = 0;
        for (i = 0; i < tp->view.rows - 3; i++)
                tp->screen[i] = tp->screen[i+1];
        tp->screen[tp->view.rows - 3] = temp;
        tty3270_rebuild_update(tp);
}

static void
tty3270_ri(struct tty3270 *tp)
{
        if (tp->cy > 0) {
            tty3270_convert_line(tp, tp->cy);
            tp->cy--;
        }
}

/*
 * Insert characters at current position.
 */
static void
tty3270_insert_characters(struct tty3270 *tp, int n)
{
        struct tty3270_line *line;
        int k;

        line = tp->screen + tp->cy;
        while (line->len < tp->cx) {
                line->cells[line->len].character = tp->view.ascebc[' '];
                line->cells[line->len].highlight = TAX_RESET;
                line->cells[line->len].f_color = TAC_RESET;
                line->len++;
        }
        if (n > tp->view.cols - tp->cx)
                n = tp->view.cols - tp->cx;
        k = min_t(int, line->len - tp->cx, tp->view.cols - tp->cx - n);
        while (k--)
                line->cells[tp->cx + n + k] = line->cells[tp->cx + k];
        line->len += n;
        if (line->len > tp->view.cols)
                line->len = tp->view.cols;
        while (n-- > 0) {
                line->cells[tp->cx + n].character = tp->view.ascebc[' '];
                line->cells[tp->cx + n].highlight = tp->highlight;
                line->cells[tp->cx + n].f_color = tp->f_color;
        }
}

/*
 * Delete characters at current position.
 */
static void
tty3270_delete_characters(struct tty3270 *tp, int n)
{
        struct tty3270_line *line;
        int i;

        line = tp->screen + tp->cy;
        if (line->len <= tp->cx)
                return;
        if (line->len - tp->cx <= n) {
                line->len = tp->cx;
                return;
        }
        for (i = tp->cx; i + n < line->len; i++)
                line->cells[i] = line->cells[i + n];
        line->len -= n;
}

/*
 * Erase characters at current position.
 */
static void
tty3270_erase_characters(struct tty3270 *tp, int n)
{
        struct tty3270_line *line;
        struct tty3270_cell *cell;

        line = tp->screen + tp->cy;
        while (line->len > tp->cx && n-- > 0) {
                cell = line->cells + tp->cx++;
                cell->character = ' ';
                cell->highlight = TAX_RESET;
                cell->f_color = TAC_RESET;
        }
        tp->cx += n;
        tp->cx = min_t(int, tp->cx, tp->view.cols - 1);
}

/*
 * Erase line, 3 different cases:
 *  Esc [ 0 K   Erase from current position to end of line inclusive
 *  Esc [ 1 K   Erase from beginning of line to current position inclusive
 *  Esc [ 2 K   Erase entire line (without moving cursor)
 */
static void
tty3270_erase_line(struct tty3270 *tp, int mode)
{
        struct tty3270_line *line;
        struct tty3270_cell *cell;
        int i;

        line = tp->screen + tp->cy;
        if (mode == 0)
                line->len = tp->cx;
        else if (mode == 1) {
                for (i = 0; i < tp->cx; i++) {
                        cell = line->cells + i;
                        cell->character = ' ';
                        cell->highlight = TAX_RESET;
                        cell->f_color = TAC_RESET;
                }
                if (line->len <= tp->cx)
                        line->len = tp->cx + 1;
        } else if (mode == 2)
                line->len = 0;
        tty3270_convert_line(tp, tp->cy);
}

/*
 * Erase display, 3 different cases:
 *  Esc [ 0 J   Erase from current position to bottom of screen inclusive
 *  Esc [ 1 J   Erase from top of screen to current position inclusive
 *  Esc [ 2 J   Erase entire screen (without moving the cursor)
 */
static void
tty3270_erase_display(struct tty3270 *tp, int mode)
{
        int i;

        if (mode == 0) {
                tty3270_erase_line(tp, 0);
                for (i = tp->cy + 1; i < tp->view.rows - 2; i++) {
                        tp->screen[i].len = 0;
                        tty3270_convert_line(tp, i);
                }
        } else if (mode == 1) {
                for (i = 0; i < tp->cy; i++) {
                        tp->screen[i].len = 0;
                        tty3270_convert_line(tp, i);
                }
                tty3270_erase_line(tp, 1);
        } else if (mode == 2) {
                for (i = 0; i < tp->view.rows - 2; i++) {
                        tp->screen[i].len = 0;
                        tty3270_convert_line(tp, i);
                }
        }
        tty3270_rebuild_update(tp);
}

/*
 * Set attributes found in an escape sequence.
 *  Esc [ <attr> ; <attr> ; ... m
 */
static void
tty3270_set_attributes(struct tty3270 *tp)
{
        static unsigned char f_colors[] = {
                TAC_DEFAULT, TAC_RED, TAC_GREEN, TAC_YELLOW, TAC_BLUE,
                TAC_PINK, TAC_TURQ, TAC_WHITE, 0, TAC_DEFAULT
        };
        int i, attr;

        for (i = 0; i <= tp->esc_npar; i++) {
                attr = tp->esc_par[i];
                switch (attr) {
                case 0:         /* Reset */
                        tp->highlight = TAX_RESET;
                        tp->f_color = TAC_RESET;
                        break;
                /* Highlight. */
                case 4:         /* Start underlining. */
                        tp->highlight = TAX_UNDER;
                        break;
                case 5:         /* Start blink. */
                        tp->highlight = TAX_BLINK;
                        break;
                case 7:         /* Start reverse. */
                        tp->highlight = TAX_REVER;
                        break;
                case 24:        /* End underlining */
                        if (tp->highlight == TAX_UNDER)
                                tp->highlight = TAX_RESET;
                        break;
                case 25:        /* End blink. */
                        if (tp->highlight == TAX_BLINK)
                                tp->highlight = TAX_RESET;
                        break;
                case 27:        /* End reverse. */
                        if (tp->highlight == TAX_REVER)
                                tp->highlight = TAX_RESET;
                        break;
                /* Foreground color. */
                case 30:        /* Black */
                case 31:        /* Red */
                case 32:        /* Green */
                case 33:        /* Yellow */
                case 34:        /* Blue */
                case 35:        /* Magenta */
                case 36:        /* Cyan */
                case 37:        /* White */
                case 39:        /* Black */
                        tp->f_color = f_colors[attr - 30];
                        break;
                }
        }
}

static inline int
tty3270_getpar(struct tty3270 *tp, int ix)
{
        return (tp->esc_par[ix] > 0) ? tp->esc_par[ix] : 1;
}

static void
tty3270_goto_xy(struct tty3270 *tp, int cx, int cy)
{
        int max_cx = max(0, cx);
        int max_cy = max(0, cy);

        tp->cx = min_t(int, tp->view.cols - 1, max_cx);
        cy = min_t(int, tp->view.rows - 3, max_cy);
        if (cy != tp->cy) {
                tty3270_convert_line(tp, tp->cy);
                tp->cy = cy;
        }
}

/*
 * Process escape sequences. Known sequences:
 *  Esc 7                       Save Cursor Position
 *  Esc 8                       Restore Cursor Position
 *  Esc [ Pn ; Pn ; .. m        Set attributes
 *  Esc [ Pn ; Pn H             Cursor Position
 *  Esc [ Pn ; Pn f             Cursor Position
 *  Esc [ Pn A                  Cursor Up
 *  Esc [ Pn B                  Cursor Down
 *  Esc [ Pn C                  Cursor Forward
 *  Esc [ Pn D                  Cursor Backward
 *  Esc [ Pn G                  Cursor Horizontal Absolute
 *  Esc [ Pn X                  Erase Characters
 *  Esc [ Ps J                  Erase in Display
 *  Esc [ Ps K                  Erase in Line
 * // FIXME: add all the new ones.
 *
 *  Pn is a numeric parameter, a string of zero or more decimal digits.
 *  Ps is a selective parameter.
 */
static void
tty3270_escape_sequence(struct tty3270 *tp, char ch)
{
        enum { ESnormal, ESesc, ESsquare, ESgetpars };

        if (tp->esc_state == ESnormal) {
                if (ch == 0x1b)
                        /* Starting new escape sequence. */
                        tp->esc_state = ESesc;
                return;
        }
        if (tp->esc_state == ESesc) {
                tp->esc_state = ESnormal;
                switch (ch) {
                case '[':
                        tp->esc_state = ESsquare;
                        break;
                case 'E':
                        tty3270_cr(tp);
                        tty3270_lf(tp);
                        break;
                case 'M':
                        tty3270_ri(tp);
                        break;
                case 'D':
                        tty3270_lf(tp);
                        break;
                case 'Z':               /* Respond ID. */
                        kbd_puts_queue(&tp->port, "\033[?6c");
                        break;
                case '7':               /* Save cursor position. */
                        tp->saved_cx = tp->cx;
                        tp->saved_cy = tp->cy;
                        tp->saved_highlight = tp->highlight;
                        tp->saved_f_color = tp->f_color;
                        break;
                case '8':               /* Restore cursor position. */
                        tty3270_convert_line(tp, tp->cy);
                        tty3270_goto_xy(tp, tp->saved_cx, tp->saved_cy);
                        tp->highlight = tp->saved_highlight;
                        tp->f_color = tp->saved_f_color;
                        break;
                case 'c':               /* Reset terminal. */
                        tp->cx = tp->saved_cx = 0;
                        tp->cy = tp->saved_cy = 0;
                        tp->highlight = tp->saved_highlight = TAX_RESET;
                        tp->f_color = tp->saved_f_color = TAC_RESET;
                        tty3270_erase_display(tp, 2);
                        break;
                }
                return;
        }
        if (tp->esc_state == ESsquare) {
                tp->esc_state = ESgetpars;
                memset(tp->esc_par, 0, sizeof(tp->esc_par));
                tp->esc_npar = 0;
                tp->esc_ques = (ch == '?');
                if (tp->esc_ques)
                        return;
        }
        if (tp->esc_state == ESgetpars) {
                if (ch == ';' && tp->esc_npar < ESCAPE_NPAR - 1) {
                        tp->esc_npar++;
                        return;
                }
                if (ch >= '0' && ch <= '9') {
                        tp->esc_par[tp->esc_npar] *= 10;
                        tp->esc_par[tp->esc_npar] += ch - '0';
                        return;
                }
        }
        tp->esc_state = ESnormal;
        if (ch == 'n' && !tp->esc_ques) {
                if (tp->esc_par[0] == 5)                /* Status report. */
                        kbd_puts_queue(&tp->port, "\033[0n");
                else if (tp->esc_par[0] == 6) { /* Cursor report. */
                        char buf[40];
                        sprintf(buf, "\033[%d;%dR", tp->cy + 1, tp->cx + 1);
                        kbd_puts_queue(&tp->port, buf);
                }
                return;
        }
        if (tp->esc_ques)
                return;
        switch (ch) {
        case 'm':
                tty3270_set_attributes(tp);
                break;
        case 'H':       /* Set cursor position. */
        case 'f':
                tty3270_goto_xy(tp, tty3270_getpar(tp, 1) - 1,
                                tty3270_getpar(tp, 0) - 1);
                break;
        case 'd':       /* Set y position. */
                tty3270_goto_xy(tp, tp->cx, tty3270_getpar(tp, 0) - 1);
                break;
        case 'A':       /* Cursor up. */
        case 'F':
                tty3270_goto_xy(tp, tp->cx, tp->cy - tty3270_getpar(tp, 0));
                break;
        case 'B':       /* Cursor down. */
        case 'e':
        case 'E':
                tty3270_goto_xy(tp, tp->cx, tp->cy + tty3270_getpar(tp, 0));
                break;
        case 'C':       /* Cursor forward. */
        case 'a':
                tty3270_goto_xy(tp, tp->cx + tty3270_getpar(tp, 0), tp->cy);
                break;
        case 'D':       /* Cursor backward. */
                tty3270_goto_xy(tp, tp->cx - tty3270_getpar(tp, 0), tp->cy);
                break;
        case 'G':       /* Set x position. */
        case '`':
                tty3270_goto_xy(tp, tty3270_getpar(tp, 0), tp->cy);
                break;
        case 'X':       /* Erase Characters. */
                tty3270_erase_characters(tp, tty3270_getpar(tp, 0));
                break;
        case 'J':       /* Erase display. */
                tty3270_erase_display(tp, tp->esc_par[0]);
                break;
        case 'K':       /* Erase line. */
                tty3270_erase_line(tp, tp->esc_par[0]);
                break;
        case 'P':       /* Delete characters. */
                tty3270_delete_characters(tp, tty3270_getpar(tp, 0));
                break;
        case '@':       /* Insert characters. */
                tty3270_insert_characters(tp, tty3270_getpar(tp, 0));
                break;
        case 's':       /* Save cursor position. */
                tp->saved_cx = tp->cx;
                tp->saved_cy = tp->cy;
                tp->saved_highlight = tp->highlight;
                tp->saved_f_color = tp->f_color;
                break;
        case 'u':       /* Restore cursor position. */
                tty3270_convert_line(tp, tp->cy);
                tty3270_goto_xy(tp, tp->saved_cx, tp->saved_cy);
                tp->highlight = tp->saved_highlight;
                tp->f_color = tp->saved_f_color;
                break;
        }
}

/*
 * String write routine for 3270 ttys
 */
static void
tty3270_do_write(struct tty3270 *tp, struct tty_struct *tty,
                const unsigned char *buf, int count)
{
        int i_msg, i;

        spin_lock_bh(&tp->view.lock);
        for (i_msg = 0; !tty->stopped && i_msg < count; i_msg++) {
                if (tp->esc_state != 0) {
                        /* Continue escape sequence. */
                        tty3270_escape_sequence(tp, buf[i_msg]);
                        continue;
                }

                switch (buf[i_msg]) {
                case 0x07:              /* '\a' -- Alarm */
                        tp->wcc |= TW_PLUSALARM;
                        break;
                case 0x08:              /* Backspace. */
                        if (tp->cx > 0) {
                                tp->cx--;
                                tty3270_put_character(tp, ' ');
                        }
                        break;
                case 0x09:              /* '\t' -- Tabulate */
                        for (i = tp->cx % 8; i < 8; i++) {
                                if (tp->cx >= tp->view.cols) {
                                        tty3270_cr(tp);
                                        tty3270_lf(tp);
                                        break;
                                }
                                tty3270_put_character(tp, ' ');
                                tp->cx++;
                        }
                        break;
                case 0x0a:              /* '\n' -- New Line */
                        tty3270_cr(tp);
                        tty3270_lf(tp);
                        break;
                case 0x0c:              /* '\f' -- Form Feed */
                        tty3270_erase_display(tp, 2);
                        tp->cx = tp->cy = 0;
                        break;
                case 0x0d:              /* '\r' -- Carriage Return */
                        tp->cx = 0;
                        break;
                case 0x0f:              /* SuSE "exit alternate mode" */
                        break;
                case 0x1b:              /* Start escape sequence. */
                        tty3270_escape_sequence(tp, buf[i_msg]);
                        break;
                default:                /* Insert normal character. */
                        if (tp->cx >= tp->view.cols) {
                                tty3270_cr(tp);
                                tty3270_lf(tp);
                        }
                        tty3270_put_character(tp, buf[i_msg]);
                        tp->cx++;
                        break;
                }
        }
        /* Convert current line to 3270 data fragment. */
        tty3270_convert_line(tp, tp->cy);

        /* Setup timer to update display after 1/10 second */
        if (!timer_pending(&tp->timer))
                tty3270_set_timer(tp, HZ/10);

        spin_unlock_bh(&tp->view.lock);
}

/*
 * String write routine for 3270 ttys
 */
static int
tty3270_write(struct tty_struct * tty,
              const unsigned char *buf, int count)
{
        struct tty3270 *tp;

        tp = tty->driver_data;
        if (!tp)
                return 0;
        if (tp->char_count > 0) {
                tty3270_do_write(tp, tty, tp->char_buf, tp->char_count);
                tp->char_count = 0;
        }
        tty3270_do_write(tp, tty, buf, count);
        return count;
}

/*
 * Put single characters to the ttys character buffer
 */
static int tty3270_put_char(struct tty_struct *tty, unsigned char ch)
{
        struct tty3270 *tp;

        tp = tty->driver_data;
        if (!tp || tp->char_count >= TTY3270_CHAR_BUF_SIZE)
                return 0;
        tp->char_buf[tp->char_count++] = ch;
        return 1;
}

/*
 * Flush all characters from the ttys characeter buffer put there
 * by tty3270_put_char.
 */
static void
tty3270_flush_chars(struct tty_struct *tty)
{
        struct tty3270 *tp;

        tp = tty->driver_data;
        if (!tp)
                return;
        if (tp->char_count > 0) {
                tty3270_do_write(tp, tty, tp->char_buf, tp->char_count);
                tp->char_count = 0;
        }
}

/*
 * Returns the number of characters in the output buffer. This is
 * used in tty_wait_until_sent to wait until all characters have
 * appeared on the screen.
 */
static int
tty3270_chars_in_buffer(struct tty_struct *tty)
{
        return 0;
}

static void
tty3270_flush_buffer(struct tty_struct *tty)
{
}

/*
 * Check for visible/invisible input switches
 */
static void
tty3270_set_termios(struct tty_struct *tty, struct ktermios *old)
{
        struct tty3270 *tp;
        int new;

        tp = tty->driver_data;
        if (!tp)
                return;
        spin_lock_bh(&tp->view.lock);
        if (L_ICANON(tty)) {
                new = L_ECHO(tty) ? TF_INPUT: TF_INPUTN;
                if (new != tp->inattr) {
                        tp->inattr = new;
                        tty3270_update_prompt(tp, NULL, 0);
                        tty3270_set_timer(tp, 1);
                }
        }
        spin_unlock_bh(&tp->view.lock);
}

/*
 * Disable reading from a 3270 tty
 */
static void
tty3270_throttle(struct tty_struct * tty)
{
        struct tty3270 *tp;

        tp = tty->driver_data;
        if (!tp)
                return;
        tp->throttle = 1;
}

/*
 * Enable reading from a 3270 tty
 */
static void
tty3270_unthrottle(struct tty_struct * tty)
{
        struct tty3270 *tp;

        tp = tty->driver_data;
        if (!tp)
                return;
        tp->throttle = 0;
        if (tp->attn)
                tty3270_issue_read(tp, 1);
}

/*
 * Hang up the tty device.
 */
static void
tty3270_hangup(struct tty_struct *tty)
{
        // FIXME: implement
}

static void
tty3270_wait_until_sent(struct tty_struct *tty, int timeout)
{
}

static int tty3270_ioctl(struct tty_struct *tty, unsigned int cmd,
                         unsigned long arg)
{
        struct tty3270 *tp;

        tp = tty->driver_data;
        if (!tp)
                return -ENODEV;
        if (tty->flags & (1 << TTY_IO_ERROR))
                return -EIO;
        return kbd_ioctl(tp->kbd, cmd, arg);
}

#ifdef CONFIG_COMPAT
static long tty3270_compat_ioctl(struct tty_struct *tty,
                                 unsigned int cmd, unsigned long arg)
{
        struct tty3270 *tp;

        tp = tty->driver_data;
        if (!tp)
                return -ENODEV;
        if (tty->flags & (1 << TTY_IO_ERROR))
                return -EIO;
        return kbd_ioctl(tp->kbd, cmd, (unsigned long)compat_ptr(arg));
}
#endif

static const struct tty_operations tty3270_ops = {
        .install = tty3270_install,
        .cleanup = tty3270_cleanup,
        .open = tty3270_open,
        .close = tty3270_close,
        .write = tty3270_write,
        .put_char = tty3270_put_char,
        .flush_chars = tty3270_flush_chars,
        .write_room = tty3270_write_room,
        .chars_in_buffer = tty3270_chars_in_buffer,
        .flush_buffer = tty3270_flush_buffer,
        .throttle = tty3270_throttle,
        .unthrottle = tty3270_unthrottle,
        .hangup = tty3270_hangup,
        .wait_until_sent = tty3270_wait_until_sent,
        .ioctl = tty3270_ioctl,
#ifdef CONFIG_COMPAT
        .compat_ioctl = tty3270_compat_ioctl,
#endif
        .set_termios = tty3270_set_termios
};

void tty3270_create_cb(int minor)
{
        tty_register_device(tty3270_driver, minor, NULL);
}

void tty3270_destroy_cb(int minor)
{
        tty_unregister_device(tty3270_driver, minor);
}

struct raw3270_notifier tty3270_notifier =
{
        .create = tty3270_create_cb,
        .destroy = tty3270_destroy_cb,
};

/*
 * 3270 tty registration code called from tty_init().
 * Most kernel services (incl. kmalloc) are available at this poimt.
 */
static int __init tty3270_init(void)
{
        struct tty_driver *driver;
        int ret;

        driver = tty_alloc_driver(RAW3270_MAXDEVS,
                                  TTY_DRIVER_REAL_RAW |
                                  TTY_DRIVER_DYNAMIC_DEV |
                                  TTY_DRIVER_RESET_TERMIOS);
        if (IS_ERR(driver))
                return PTR_ERR(driver);

        /*
         * Initialize the tty_driver structure
         * Entries in tty3270_driver that are NOT initialized:
         * proc_entry, set_termios, flush_buffer, set_ldisc, write_proc
         */
        driver->driver_name = "tty3270";
        driver->name = "3270/tty";
        driver->major = IBM_TTY3270_MAJOR;
        driver->minor_start = 0;
        driver->type = TTY_DRIVER_TYPE_SYSTEM;
        driver->subtype = SYSTEM_TYPE_TTY;
        driver->init_termios = tty_std_termios;
        tty_set_operations(driver, &tty3270_ops);
        ret = tty_register_driver(driver);
        if (ret) {
                put_tty_driver(driver);
                return ret;
        }
        tty3270_driver = driver;
        raw3270_register_notifier(&tty3270_notifier);
        return 0;
}

static void __exit
tty3270_exit(void)
{
        struct tty_driver *driver;

        raw3270_unregister_notifier(&tty3270_notifier);
        driver = tty3270_driver;
        tty3270_driver = NULL;
        tty_unregister_driver(driver);
        put_tty_driver(driver);
        tty3270_del_views();
}

MODULE_LICENSE("GPL");
MODULE_ALIAS_CHARDEV_MAJOR(IBM_TTY3270_MAJOR);

module_init(tty3270_init);
module_exit(tty3270_exit);