// SPDX-License-Identifier: GPL-2.0
/*
 * IBM/3270 Driver - core 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, 2009
 */

#include <linux/module.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/wait.h>

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

#include "raw3270.h"

#include <linux/major.h>
#include <linux/kdev_t.h>
#include <linux/device.h>
#include <linux/mutex.h>

struct class *class3270;

/* The main 3270 data structure. */
struct raw3270 {
        struct list_head list;
        struct ccw_device *cdev;
        int minor;

        short model, rows, cols;
        unsigned int state;
        unsigned long flags;

        struct list_head req_queue;     /* Request queue. */
        struct list_head view_list;     /* List of available views. */
        struct raw3270_view *view;      /* Active view. */

        struct timer_list timer;        /* Device timer. */

        unsigned char *ascebc;          /* ascii -> ebcdic table */

        struct raw3270_view init_view;
        struct raw3270_request init_reset;
        struct raw3270_request init_readpart;
        struct raw3270_request init_readmod;
        unsigned char init_data[256];
};

/* raw3270->state */
#define RAW3270_STATE_INIT      0       /* Initial state */
#define RAW3270_STATE_RESET     1       /* Reset command is pending */
#define RAW3270_STATE_W4ATTN    2       /* Wait for attention interrupt */
#define RAW3270_STATE_READMOD   3       /* Read partition is pending */
#define RAW3270_STATE_READY     4       /* Device is usable by views */

/* raw3270->flags */
#define RAW3270_FLAGS_14BITADDR 0       /* 14-bit buffer addresses */
#define RAW3270_FLAGS_BUSY      1       /* Device busy, leave it alone */
#define RAW3270_FLAGS_CONSOLE   2       /* Device is the console. */
#define RAW3270_FLAGS_FROZEN    3       /* set if 3270 is frozen for suspend */

/* Semaphore to protect global data of raw3270 (devices, views, etc). */
static DEFINE_MUTEX(raw3270_mutex);

/* List of 3270 devices. */
static LIST_HEAD(raw3270_devices);

/*
 * Flag to indicate if the driver has been registered. Some operations
 * like waiting for the end of i/o need to be done differently as long
 * as the kernel is still starting up (console support).
 */
static int raw3270_registered;

/* Module parameters */
static bool tubxcorrect;
module_param(tubxcorrect, bool, 0);

/*
 * Wait queue for device init/delete, view delete.
 */
DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);

static void __raw3270_disconnect(struct raw3270 *rp);

/*
 * Encode array for 12 bit 3270 addresses.
 */
static unsigned char raw3270_ebcgraf[64] =      {
        0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
        0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
        0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
        0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
        0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
        0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
        0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
};

static inline int raw3270_state_ready(struct raw3270 *rp)
{
        return rp->state == RAW3270_STATE_READY;
}

static inline int raw3270_state_final(struct raw3270 *rp)
{
        return rp->state == RAW3270_STATE_INIT ||
                rp->state == RAW3270_STATE_READY;
}

void
raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr)
{
        if (test_bit(RAW3270_FLAGS_14BITADDR, &rp->flags)) {
                cp[0] = (addr >> 8) & 0x3f;
                cp[1] = addr & 0xff;
        } else {
                cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f];
                cp[1] = raw3270_ebcgraf[addr & 0x3f];
        }
}

/*
 * Allocate a new 3270 ccw request
 */
struct raw3270_request *
raw3270_request_alloc(size_t size)
{
        struct raw3270_request *rq;

        /* Allocate request structure */
        rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
        if (!rq)
                return ERR_PTR(-ENOMEM);

        /* alloc output buffer. */
        if (size > 0) {
                rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
                if (!rq->buffer) {
                        kfree(rq);
                        return ERR_PTR(-ENOMEM);
                }
        }
        rq->size = size;
        INIT_LIST_HEAD(&rq->list);

        /*
         * Setup ccw.
         */
        rq->ccw.cda = __pa(rq->buffer);
        rq->ccw.flags = CCW_FLAG_SLI;

        return rq;
}

/*
 * Free 3270 ccw request
 */
void
raw3270_request_free (struct raw3270_request *rq)
{
        kfree(rq->buffer);
        kfree(rq);
}

/*
 * Reset request to initial state.
 */
void
raw3270_request_reset(struct raw3270_request *rq)
{
        BUG_ON(!list_empty(&rq->list));
        rq->ccw.cmd_code = 0;
        rq->ccw.count = 0;
        rq->ccw.cda = __pa(rq->buffer);
        rq->ccw.flags = CCW_FLAG_SLI;
        rq->rescnt = 0;
        rq->rc = 0;
}

/*
 * Set command code to ccw of a request.
 */
void
raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd)
{
        rq->ccw.cmd_code = cmd;
}

/*
 * Add data fragment to output buffer.
 */
int
raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size)
{
        if (size + rq->ccw.count > rq->size)
                return -E2BIG;
        memcpy(rq->buffer + rq->ccw.count, data, size);
        rq->ccw.count += size;
        return 0;
}

/*
 * Set address/length pair to ccw of a request.
 */
void
raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size)
{
        rq->ccw.cda = __pa(data);
        rq->ccw.count = size;
}

/*
 * Set idal buffer to ccw of a request.
 */
void
raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
{
        rq->ccw.cda = __pa(ib->data);
        rq->ccw.count = ib->size;
        rq->ccw.flags |= CCW_FLAG_IDA;
}

/*
 * Add the request to the request queue, try to start it if the
 * 3270 device is idle. Return without waiting for end of i/o.
 */
static int
__raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
                struct raw3270_request *rq)
{
        rq->view = view;
        raw3270_get_view(view);
        if (list_empty(&rp->req_queue) &&
            !test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
                /* No other requests are on the queue. Start this one. */
                rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
                                               (unsigned long) rq, 0, 0);
                if (rq->rc) {
                        raw3270_put_view(view);
                        return rq->rc;
                }
        }
        list_add_tail(&rq->list, &rp->req_queue);
        return 0;
}

int
raw3270_view_active(struct raw3270_view *view)
{
        struct raw3270 *rp = view->dev;

        return rp && rp->view == view &&
                !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
}

int
raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
{
        unsigned long flags;
        struct raw3270 *rp;
        int rc;

        spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
        rp = view->dev;
        if (!rp || rp->view != view ||
            test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                rc = -EACCES;
        else if (!raw3270_state_ready(rp))
                rc = -EBUSY;
        else
                rc =  __raw3270_start(rp, view, rq);
        spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
        return rc;
}

int
raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
{
        struct raw3270 *rp;
        int rc;

        rp = view->dev;
        if (!rp || rp->view != view ||
            test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                rc = -EACCES;
        else if (!raw3270_state_ready(rp))
                rc = -EBUSY;
        else
                rc =  __raw3270_start(rp, view, rq);
        return rc;
}

int
raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
{
        struct raw3270 *rp;

        rp = view->dev;
        rq->view = view;
        raw3270_get_view(view);
        list_add_tail(&rq->list, &rp->req_queue);
        return 0;
}

/*
 * 3270 interrupt routine, called from the ccw_device layer
 */
static void
raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
{
        struct raw3270 *rp;
        struct raw3270_view *view;
        struct raw3270_request *rq;

        rp = dev_get_drvdata(&cdev->dev);
        if (!rp)
                return;
        rq = (struct raw3270_request *) intparm;
        view = rq ? rq->view : rp->view;

        if (!IS_ERR(irb)) {
                /* Handle CE-DE-UE and subsequent UDE */
                if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END)
                        clear_bit(RAW3270_FLAGS_BUSY, &rp->flags);
                if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END |
                                            DEV_STAT_DEV_END |
                                            DEV_STAT_UNIT_EXCEP))
                        set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
                /* Handle disconnected devices */
                if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
                    (irb->ecw[0] & SNS0_INTERVENTION_REQ)) {
                        set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
                        if (rp->state > RAW3270_STATE_RESET)
                                __raw3270_disconnect(rp);
                }
                /* Call interrupt handler of the view */
                if (view)
                        view->fn->intv(view, rq, irb);
        }

        if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags))
                /* Device busy, do not start I/O */
                return;

        if (rq && !list_empty(&rq->list)) {
                /* The request completed, remove from queue and do callback. */
                list_del_init(&rq->list);
                if (rq->callback)
                        rq->callback(rq, rq->callback_data);
                /* Do put_device for get_device in raw3270_start. */
                raw3270_put_view(view);
        }

        /*
         * Try to start each request on request queue until one is
         * started successful.
         */
        while (!list_empty(&rp->req_queue)) {
                rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
                rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
                                          (unsigned long) rq, 0, 0);
                if (rq->rc == 0)
                        break;
                /* Start failed. Remove request and do callback. */
                list_del_init(&rq->list);
                if (rq->callback)
                        rq->callback(rq, rq->callback_data);
                /* Do put_device for get_device in raw3270_start. */
                raw3270_put_view(view);
        }
}

/*
 * To determine the size of the 3270 device we need to do:
 * 1) send a 'read partition' data stream to the device
 * 2) wait for the attn interrupt that precedes the query reply
 * 3) do a read modified to get the query reply
 * To make things worse we have to cope with intervention
 * required (3270 device switched to 'stand-by') and command
 * rejects (old devices that can't do 'read partition').
 */
struct raw3270_ua {     /* Query Reply structure for Usable Area */
        struct {        /* Usable Area Query Reply Base */
                short l;        /* Length of this structured field */
                char  sfid;     /* 0x81 if Query Reply */
                char  qcode;    /* 0x81 if Usable Area */
                char  flags0;
                char  flags1;
                short w;        /* Width of usable area */
                short h;        /* Heigth of usavle area */
                char  units;    /* 0x00:in; 0x01:mm */
                int   xr;
                int   yr;
                char  aw;
                char  ah;
                short buffsz;   /* Character buffer size, bytes */
                char  xmin;
                char  ymin;
                char  xmax;
                char  ymax;
        } __attribute__ ((packed)) uab;
        struct {        /* Alternate Usable Area Self-Defining Parameter */
                char  l;        /* Length of this Self-Defining Parm */
                char  sdpid;    /* 0x02 if Alternate Usable Area */
                char  res;
                char  auaid;    /* 0x01 is Id for the A U A */
                short wauai;    /* Width of AUAi */
                short hauai;    /* Height of AUAi */
                char  auaunits; /* 0x00:in, 0x01:mm */
                int   auaxr;
                int   auayr;
                char  awauai;
                char  ahauai;
        } __attribute__ ((packed)) aua;
} __attribute__ ((packed));

static void
raw3270_size_device_vm(struct raw3270 *rp)
{
        int rc, model;
        struct ccw_dev_id dev_id;
        struct diag210 diag_data;

        ccw_device_get_id(rp->cdev, &dev_id);
        diag_data.vrdcdvno = dev_id.devno;
        diag_data.vrdclen = sizeof(struct diag210);
        rc = diag210(&diag_data);
        model = diag_data.vrdccrmd;
        /* Use default model 2 if the size could not be detected */
        if (rc || model < 2 || model > 5)
                model = 2;
        switch (model) {
        case 2:
                rp->model = model;
                rp->rows = 24;
                rp->cols = 80;
                break;
        case 3:
                rp->model = model;
                rp->rows = 32;
                rp->cols = 80;
                break;
        case 4:
                rp->model = model;
                rp->rows = 43;
                rp->cols = 80;
                break;
        case 5:
                rp->model = model;
                rp->rows = 27;
                rp->cols = 132;
                break;
        }
}

static void
raw3270_size_device(struct raw3270 *rp)
{
        struct raw3270_ua *uap;

        /* Got a Query Reply */
        uap = (struct raw3270_ua *) (rp->init_data + 1);
        /* Paranoia check. */
        if (rp->init_readmod.rc || rp->init_data[0] != 0x88 ||
            uap->uab.qcode != 0x81) {
                /* Couldn't detect size. Use default model 2. */
                rp->model = 2;
                rp->rows = 24;
                rp->cols = 80;
                return;
        }
        /* Copy rows/columns of default Usable Area */
        rp->rows = uap->uab.h;
        rp->cols = uap->uab.w;
        /* Check for 14 bit addressing */
        if ((uap->uab.flags0 & 0x0d) == 0x01)
                set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
        /* Check for Alternate Usable Area */
        if (uap->uab.l == sizeof(struct raw3270_ua) &&
            uap->aua.sdpid == 0x02) {
                rp->rows = uap->aua.hauai;
                rp->cols = uap->aua.wauai;
        }
        /* Try to find a model. */
        rp->model = 0;
        if (rp->rows == 24 && rp->cols == 80)
                rp->model = 2;
        if (rp->rows == 32 && rp->cols == 80)
                rp->model = 3;
        if (rp->rows == 43 && rp->cols == 80)
                rp->model = 4;
        if (rp->rows == 27 && rp->cols == 132)
                rp->model = 5;
}

static void
raw3270_size_device_done(struct raw3270 *rp)
{
        struct raw3270_view *view;

        rp->view = NULL;
        rp->state = RAW3270_STATE_READY;
        /* Notify views about new size */
        list_for_each_entry(view, &rp->view_list, list)
                if (view->fn->resize)
                        view->fn->resize(view, rp->model, rp->rows, rp->cols);
        /* Setup processing done, now activate a view */
        list_for_each_entry(view, &rp->view_list, list) {
                rp->view = view;
                if (view->fn->activate(view) == 0)
                        break;
                rp->view = NULL;
        }
}

static void
raw3270_read_modified_cb(struct raw3270_request *rq, void *data)
{
        struct raw3270 *rp = rq->view->dev;

        raw3270_size_device(rp);
        raw3270_size_device_done(rp);
}

static void
raw3270_read_modified(struct raw3270 *rp)
{
        if (rp->state != RAW3270_STATE_W4ATTN)
                return;
        /* Use 'read modified' to get the result of a read partition. */
        memset(&rp->init_readmod, 0, sizeof(rp->init_readmod));
        memset(&rp->init_data, 0, sizeof(rp->init_data));
        rp->init_readmod.ccw.cmd_code = TC_READMOD;
        rp->init_readmod.ccw.flags = CCW_FLAG_SLI;
        rp->init_readmod.ccw.count = sizeof(rp->init_data);
        rp->init_readmod.ccw.cda = (__u32) __pa(rp->init_data);
        rp->init_readmod.callback = raw3270_read_modified_cb;
        rp->state = RAW3270_STATE_READMOD;
        raw3270_start_irq(&rp->init_view, &rp->init_readmod);
}

static void
raw3270_writesf_readpart(struct raw3270 *rp)
{
        static const unsigned char wbuf[] =
                { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };

        /* Store 'read partition' data stream to init_data */
        memset(&rp->init_readpart, 0, sizeof(rp->init_readpart));
        memset(&rp->init_data, 0, sizeof(rp->init_data));
        memcpy(&rp->init_data, wbuf, sizeof(wbuf));
        rp->init_readpart.ccw.cmd_code = TC_WRITESF;
        rp->init_readpart.ccw.flags = CCW_FLAG_SLI;
        rp->init_readpart.ccw.count = sizeof(wbuf);
        rp->init_readpart.ccw.cda = (__u32) __pa(&rp->init_data);
        rp->state = RAW3270_STATE_W4ATTN;
        raw3270_start_irq(&rp->init_view, &rp->init_readpart);
}

/*
 * Device reset
 */
static void
raw3270_reset_device_cb(struct raw3270_request *rq, void *data)
{
        struct raw3270 *rp = rq->view->dev;

        if (rp->state != RAW3270_STATE_RESET)
                return;
        if (rq->rc) {
                /* Reset command failed. */
                rp->state = RAW3270_STATE_INIT;
        } else if (MACHINE_IS_VM) {
                raw3270_size_device_vm(rp);
                raw3270_size_device_done(rp);
        } else
                raw3270_writesf_readpart(rp);
        memset(&rp->init_reset, 0, sizeof(rp->init_reset));
}

static int
__raw3270_reset_device(struct raw3270 *rp)
{
        int rc;

        /* Check if reset is already pending */
        if (rp->init_reset.view)
                return -EBUSY;
        /* Store reset data stream to init_data/init_reset */
        rp->init_data[0] = TW_KR;
        rp->init_reset.ccw.cmd_code = TC_EWRITEA;
        rp->init_reset.ccw.flags = CCW_FLAG_SLI;
        rp->init_reset.ccw.count = 1;
        rp->init_reset.ccw.cda = (__u32) __pa(rp->init_data);
        rp->init_reset.callback = raw3270_reset_device_cb;
        rc = __raw3270_start(rp, &rp->init_view, &rp->init_reset);
        if (rc == 0 && rp->state == RAW3270_STATE_INIT)
                rp->state = RAW3270_STATE_RESET;
        return rc;
}

static int
raw3270_reset_device(struct raw3270 *rp)
{
        unsigned long flags;
        int rc;

        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
        rc = __raw3270_reset_device(rp);
        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
        return rc;
}

int
raw3270_reset(struct raw3270_view *view)
{
        struct raw3270 *rp;
        int rc;

        rp = view->dev;
        if (!rp || rp->view != view ||
            test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                rc = -EACCES;
        else if (!raw3270_state_ready(rp))
                rc = -EBUSY;
        else
                rc = raw3270_reset_device(view->dev);
        return rc;
}

static void
__raw3270_disconnect(struct raw3270 *rp)
{
        struct raw3270_request *rq;
        struct raw3270_view *view;

        rp->state = RAW3270_STATE_INIT;
        rp->view = &rp->init_view;
        /* Cancel all queued requests */
        while (!list_empty(&rp->req_queue)) {
                rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
                view = rq->view;
                rq->rc = -EACCES;
                list_del_init(&rq->list);
                if (rq->callback)
                        rq->callback(rq, rq->callback_data);
                raw3270_put_view(view);
        }
        /* Start from scratch */
        __raw3270_reset_device(rp);
}

static void
raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
                 struct irb *irb)
{
        struct raw3270 *rp;

        if (rq) {
                if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
                        if (irb->ecw[0] & SNS0_CMD_REJECT)
                                rq->rc = -EOPNOTSUPP;
                        else
                                rq->rc = -EIO;
                }
        }
        if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
                /* Queue read modified after attention interrupt */
                rp = view->dev;
                raw3270_read_modified(rp);
        }
}

static struct raw3270_fn raw3270_init_fn = {
        .intv = raw3270_init_irq
};

/*
 * Setup new 3270 device.
 */
static int
raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
{
        struct list_head *l;
        struct raw3270 *tmp;
        int minor;

        memset(rp, 0, sizeof(struct raw3270));
        /* Copy ebcdic -> ascii translation table. */
        memcpy(ascebc, _ascebc, 256);
        if (tubxcorrect) {
                /* correct brackets and circumflex */
                ascebc['['] = 0xad;
                ascebc[']'] = 0xbd;
                ascebc['^'] = 0xb0;
        }
        rp->ascebc = ascebc;

        /* Set defaults. */
        rp->rows = 24;
        rp->cols = 80;

        INIT_LIST_HEAD(&rp->req_queue);
        INIT_LIST_HEAD(&rp->view_list);

        rp->init_view.dev = rp;
        rp->init_view.fn = &raw3270_init_fn;
        rp->view = &rp->init_view;

        /*
         * Add device to list and find the smallest unused minor
         * number for it. Note: there is no device with minor 0,
         * see special case for fs3270.c:fs3270_open().
         */
        mutex_lock(&raw3270_mutex);
        /* Keep the list sorted. */
        minor = RAW3270_FIRSTMINOR;
        rp->minor = -1;
        list_for_each(l, &raw3270_devices) {
                tmp = list_entry(l, struct raw3270, list);
                if (tmp->minor > minor) {
                        rp->minor = minor;
                        __list_add(&rp->list, l->prev, l);
                        break;
                }
                minor++;
        }
        if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
                rp->minor = minor;
                list_add_tail(&rp->list, &raw3270_devices);
        }
        mutex_unlock(&raw3270_mutex);
        /* No free minor number? Then give up. */
        if (rp->minor == -1)
                return -EUSERS;
        rp->cdev = cdev;
        dev_set_drvdata(&cdev->dev, rp);
        cdev->handler = raw3270_irq;
        return 0;
}

#ifdef CONFIG_TN3270_CONSOLE
/* Tentative definition - see below for actual definition. */
static struct ccw_driver raw3270_ccw_driver;

/*
 * Setup 3270 device configured as console.
 */
struct raw3270 __init *raw3270_setup_console(void)
{
        struct ccw_device *cdev;
        unsigned long flags;
        struct raw3270 *rp;
        char *ascebc;
        int rc;

        cdev = ccw_device_create_console(&raw3270_ccw_driver);
        if (IS_ERR(cdev))
                return ERR_CAST(cdev);

        rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
        ascebc = kzalloc(256, GFP_KERNEL);
        rc = raw3270_setup_device(cdev, rp, ascebc);
        if (rc)
                return ERR_PTR(rc);
        set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);

        rc = ccw_device_enable_console(cdev);
        if (rc) {
                ccw_device_destroy_console(cdev);
                return ERR_PTR(rc);
        }

        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
        do {
                __raw3270_reset_device(rp);
                while (!raw3270_state_final(rp)) {
                        ccw_device_wait_idle(rp->cdev);
                        barrier();
                }
        } while (rp->state != RAW3270_STATE_READY);
        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
        return rp;
}

void
raw3270_wait_cons_dev(struct raw3270 *rp)
{
        unsigned long flags;

        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
        ccw_device_wait_idle(rp->cdev);
        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
}

#endif

/*
 * Create a 3270 device structure.
 */
static struct raw3270 *
raw3270_create_device(struct ccw_device *cdev)
{
        struct raw3270 *rp;
        char *ascebc;
        int rc;

        rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
        if (!rp)
                return ERR_PTR(-ENOMEM);
        ascebc = kmalloc(256, GFP_KERNEL);
        if (!ascebc) {
                kfree(rp);
                return ERR_PTR(-ENOMEM);
        }
        rc = raw3270_setup_device(cdev, rp, ascebc);
        if (rc) {
                kfree(rp->ascebc);
                kfree(rp);
                rp = ERR_PTR(rc);
        }
        /* Get reference to ccw_device structure. */
        get_device(&cdev->dev);
        return rp;
}

/*
 * Activate a view.
 */
int
raw3270_activate_view(struct raw3270_view *view)
{
        struct raw3270 *rp;
        struct raw3270_view *oldview, *nv;
        unsigned long flags;
        int rc;

        rp = view->dev;
        if (!rp)
                return -ENODEV;
        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
        if (rp->view == view)
                rc = 0;
        else if (!raw3270_state_ready(rp))
                rc = -EBUSY;
        else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                rc = -EACCES;
        else {
                oldview = NULL;
                if (rp->view && rp->view->fn->deactivate) {
                        oldview = rp->view;
                        oldview->fn->deactivate(oldview);
                }
                rp->view = view;
                rc = view->fn->activate(view);
                if (rc) {
                        /* Didn't work. Try to reactivate the old view. */
                        rp->view = oldview;
                        if (!oldview || oldview->fn->activate(oldview) != 0) {
                                /* Didn't work as well. Try any other view. */
                                list_for_each_entry(nv, &rp->view_list, list)
                                        if (nv != view && nv != oldview) {
                                                rp->view = nv;
                                                if (nv->fn->activate(nv) == 0)
                                                        break;
                                                rp->view = NULL;
                                        }
                        }
                }
        }
        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
        return rc;
}

/*
 * Deactivate current view.
 */
void
raw3270_deactivate_view(struct raw3270_view *view)
{
        unsigned long flags;
        struct raw3270 *rp;

        rp = view->dev;
        if (!rp)
                return;
        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
        if (rp->view == view) {
                view->fn->deactivate(view);
                rp->view = NULL;
                /* Move deactivated view to end of list. */
                list_del_init(&view->list);
                list_add_tail(&view->list, &rp->view_list);
                /* Try to activate another view. */
                if (raw3270_state_ready(rp) &&
                    !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
                        list_for_each_entry(view, &rp->view_list, list) {
                                rp->view = view;
                                if (view->fn->activate(view) == 0)
                                        break;
                                rp->view = NULL;
                        }
                }
        }
        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
}

/*
 * Add view to device with minor "minor".
 */
int
raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor, int subclass)
{
        unsigned long flags;
        struct raw3270 *rp;
        int rc;

        if (minor <= 0)
                return -ENODEV;
        mutex_lock(&raw3270_mutex);
        rc = -ENODEV;
        list_for_each_entry(rp, &raw3270_devices, list) {
                if (rp->minor != minor)
                        continue;
                spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
                atomic_set(&view->ref_count, 2);
                view->dev = rp;
                view->fn = fn;
                view->model = rp->model;
                view->rows = rp->rows;
                view->cols = rp->cols;
                view->ascebc = rp->ascebc;
                spin_lock_init(&view->lock);
                lockdep_set_subclass(&view->lock, subclass);
                list_add(&view->list, &rp->view_list);
                rc = 0;
                spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
                break;
        }
        mutex_unlock(&raw3270_mutex);
        return rc;
}

/*
 * Find specific view of device with minor "minor".
 */
struct raw3270_view *
raw3270_find_view(struct raw3270_fn *fn, int minor)
{
        struct raw3270 *rp;
        struct raw3270_view *view, *tmp;
        unsigned long flags;

        mutex_lock(&raw3270_mutex);
        view = ERR_PTR(-ENODEV);
        list_for_each_entry(rp, &raw3270_devices, list) {
                if (rp->minor != minor)
                        continue;
                spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
                list_for_each_entry(tmp, &rp->view_list, list) {
                        if (tmp->fn == fn) {
                                raw3270_get_view(tmp);
                                view = tmp;
                                break;
                        }
                }
                spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
                break;
        }
        mutex_unlock(&raw3270_mutex);
        return view;
}

/*
 * Remove view from device and free view structure via call to view->fn->free.
 */
void
raw3270_del_view(struct raw3270_view *view)
{
        unsigned long flags;
        struct raw3270 *rp;
        struct raw3270_view *nv;

        rp = view->dev;
        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
        if (rp->view == view) {
                view->fn->deactivate(view);
                rp->view = NULL;
        }

        list_del_init(&view->list);
        if (!rp->view && raw3270_state_ready(rp) &&
            !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
                /* Try to activate another view. */
                list_for_each_entry(nv, &rp->view_list, list) {
                        if (nv->fn->activate(nv) == 0) {
                                rp->view = nv;
                                break;
                        }
                }
        }
        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
        /* Wait for reference counter to drop to zero. */
        atomic_dec(&view->ref_count);
        wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
        if (view->fn->free)
                view->fn->free(view);
}

/*
 * Remove a 3270 device structure.
 */
static void
raw3270_delete_device(struct raw3270 *rp)
{
        struct ccw_device *cdev;

        /* Remove from device chain. */
        mutex_lock(&raw3270_mutex);
        list_del_init(&rp->list);
        mutex_unlock(&raw3270_mutex);

        /* Disconnect from ccw_device. */
        cdev = rp->cdev;
        rp->cdev = NULL;
        dev_set_drvdata(&cdev->dev, NULL);
        cdev->handler = NULL;

        /* Put ccw_device structure. */
        put_device(&cdev->dev);

        /* Now free raw3270 structure. */
        kfree(rp->ascebc);
        kfree(rp);
}

static int
raw3270_probe (struct ccw_device *cdev)
{
        return 0;
}

/*
 * Additional attributes for a 3270 device
 */
static ssize_t
raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        return snprintf(buf, PAGE_SIZE, "%i\n",
                        ((struct raw3270 *) dev_get_drvdata(dev))->model);
}
static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);

static ssize_t
raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        return snprintf(buf, PAGE_SIZE, "%i\n",
                        ((struct raw3270 *) dev_get_drvdata(dev))->rows);
}
static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);

static ssize_t
raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        return snprintf(buf, PAGE_SIZE, "%i\n",
                        ((struct raw3270 *) dev_get_drvdata(dev))->cols);
}
static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);

static struct attribute * raw3270_attrs[] = {
        &dev_attr_model.attr,
        &dev_attr_rows.attr,
        &dev_attr_columns.attr,
        NULL,
};

static const struct attribute_group raw3270_attr_group = {
        .attrs = raw3270_attrs,
};

static int raw3270_create_attributes(struct raw3270 *rp)
{
        return sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
}

/*
 * Notifier for device addition/removal
 */
static LIST_HEAD(raw3270_notifier);

int raw3270_register_notifier(struct raw3270_notifier *notifier)
{
        struct raw3270 *rp;

        mutex_lock(&raw3270_mutex);
        list_add_tail(&notifier->list, &raw3270_notifier);
        list_for_each_entry(rp, &raw3270_devices, list)
                notifier->create(rp->minor);
        mutex_unlock(&raw3270_mutex);
        return 0;
}

void raw3270_unregister_notifier(struct raw3270_notifier *notifier)
{
        struct raw3270 *rp;

        mutex_lock(&raw3270_mutex);
        list_for_each_entry(rp, &raw3270_devices, list)
                notifier->destroy(rp->minor);
        list_del(&notifier->list);
        mutex_unlock(&raw3270_mutex);
}

/*
 * Set 3270 device online.
 */
static int
raw3270_set_online (struct ccw_device *cdev)
{
        struct raw3270_notifier *np;
        struct raw3270 *rp;
        int rc;

        rp = raw3270_create_device(cdev);
        if (IS_ERR(rp))
                return PTR_ERR(rp);
        rc = raw3270_create_attributes(rp);
        if (rc)
                goto failure;
        raw3270_reset_device(rp);
        mutex_lock(&raw3270_mutex);
        list_for_each_entry(np, &raw3270_notifier, list)
                np->create(rp->minor);
        mutex_unlock(&raw3270_mutex);
        return 0;

failure:
        raw3270_delete_device(rp);
        return rc;
}

/*
 * Remove 3270 device structure.
 */
static void
raw3270_remove (struct ccw_device *cdev)
{
        unsigned long flags;
        struct raw3270 *rp;
        struct raw3270_view *v;
        struct raw3270_notifier *np;

        rp = dev_get_drvdata(&cdev->dev);
        /*
         * _remove is the opposite of _probe; it's probe that
         * should set up rp.  raw3270_remove gets entered for
         * devices even if they haven't been varied online.
         * Thus, rp may validly be NULL here.
         */
        if (rp == NULL)
                return;

        sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);

        /* Deactivate current view and remove all views. */
        spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
        if (rp->view) {
                if (rp->view->fn->deactivate)
                        rp->view->fn->deactivate(rp->view);
                rp->view = NULL;
        }
        while (!list_empty(&rp->view_list)) {
                v = list_entry(rp->view_list.next, struct raw3270_view, list);
                if (v->fn->release)
                        v->fn->release(v);
                spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
                raw3270_del_view(v);
                spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
        }
        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);

        mutex_lock(&raw3270_mutex);
        list_for_each_entry(np, &raw3270_notifier, list)
                np->destroy(rp->minor);
        mutex_unlock(&raw3270_mutex);

        /* Reset 3270 device. */
        raw3270_reset_device(rp);
        /* And finally remove it. */
        raw3270_delete_device(rp);
}

/*
 * Set 3270 device offline.
 */
static int
raw3270_set_offline (struct ccw_device *cdev)
{
        struct raw3270 *rp;

        rp = dev_get_drvdata(&cdev->dev);
        if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
                return -EBUSY;
        raw3270_remove(cdev);
        return 0;
}

static int raw3270_pm_stop(struct ccw_device *cdev)
{
        struct raw3270 *rp;
        struct raw3270_view *view;
        unsigned long flags;

        rp = dev_get_drvdata(&cdev->dev);
        if (!rp)
                return 0;
        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
        if (rp->view && rp->view->fn->deactivate)
                rp->view->fn->deactivate(rp->view);
        if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
                /*
                 * Release tty and fullscreen for all non-console
                 * devices.
                 */
                list_for_each_entry(view, &rp->view_list, list) {
                        if (view->fn->release)
                                view->fn->release(view);
                }
        }
        set_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
        return 0;
}

static int raw3270_pm_start(struct ccw_device *cdev)
{
        struct raw3270 *rp;
        unsigned long flags;

        rp = dev_get_drvdata(&cdev->dev);
        if (!rp)
                return 0;
        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
        clear_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
        if (rp->view && rp->view->fn->activate)
                rp->view->fn->activate(rp->view);
        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
        return 0;
}

void raw3270_pm_unfreeze(struct raw3270_view *view)
{
#ifdef CONFIG_TN3270_CONSOLE
        struct raw3270 *rp;

        rp = view->dev;
        if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                ccw_device_force_console(rp->cdev);
#endif
}

static struct ccw_device_id raw3270_id[] = {
        { CCW_DEVICE(0x3270, 0) },
        { CCW_DEVICE(0x3271, 0) },
        { CCW_DEVICE(0x3272, 0) },
        { CCW_DEVICE(0x3273, 0) },
        { CCW_DEVICE(0x3274, 0) },
        { CCW_DEVICE(0x3275, 0) },
        { CCW_DEVICE(0x3276, 0) },
        { CCW_DEVICE(0x3277, 0) },
        { CCW_DEVICE(0x3278, 0) },
        { CCW_DEVICE(0x3279, 0) },
        { CCW_DEVICE(0x3174, 0) },
        { /* end of list */ },
};

static struct ccw_driver raw3270_ccw_driver = {
        .driver = {
                .name   = "3270",
                .owner  = THIS_MODULE,
        },
        .ids            = raw3270_id,
        .probe          = &raw3270_probe,
        .remove         = &raw3270_remove,
        .set_online     = &raw3270_set_online,
        .set_offline    = &raw3270_set_offline,
        .freeze         = &raw3270_pm_stop,
        .thaw           = &raw3270_pm_start,
        .restore        = &raw3270_pm_start,
        .int_class      = IRQIO_C70,
};

static int
raw3270_init(void)
{
        struct raw3270 *rp;
        int rc;

        if (raw3270_registered)
                return 0;
        raw3270_registered = 1;
        rc = ccw_driver_register(&raw3270_ccw_driver);
        if (rc == 0) {
                /* Create attributes for early (= console) device. */
                mutex_lock(&raw3270_mutex);
                class3270 = class_create(THIS_MODULE, "3270");
                list_for_each_entry(rp, &raw3270_devices, list) {
                        get_device(&rp->cdev->dev);
                        raw3270_create_attributes(rp);
                }
                mutex_unlock(&raw3270_mutex);
        }
        return rc;
}

static void
raw3270_exit(void)
{
        ccw_driver_unregister(&raw3270_ccw_driver);
        class_destroy(class3270);
}

MODULE_LICENSE("GPL");

module_init(raw3270_init);
module_exit(raw3270_exit);

EXPORT_SYMBOL(class3270);
EXPORT_SYMBOL(raw3270_request_alloc);
EXPORT_SYMBOL(raw3270_request_free);
EXPORT_SYMBOL(raw3270_request_reset);
EXPORT_SYMBOL(raw3270_request_set_cmd);
EXPORT_SYMBOL(raw3270_request_add_data);
EXPORT_SYMBOL(raw3270_request_set_data);
EXPORT_SYMBOL(raw3270_request_set_idal);
EXPORT_SYMBOL(raw3270_buffer_address);
EXPORT_SYMBOL(raw3270_add_view);
EXPORT_SYMBOL(raw3270_del_view);
EXPORT_SYMBOL(raw3270_find_view);
EXPORT_SYMBOL(raw3270_activate_view);
EXPORT_SYMBOL(raw3270_deactivate_view);
EXPORT_SYMBOL(raw3270_start);
EXPORT_SYMBOL(raw3270_start_locked);
EXPORT_SYMBOL(raw3270_start_irq);
EXPORT_SYMBOL(raw3270_reset);
EXPORT_SYMBOL(raw3270_register_notifier);
EXPORT_SYMBOL(raw3270_unregister_notifier);
EXPORT_SYMBOL(raw3270_wait_queue);