Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux

Pull s390 update from Martin Schwidefsky:
 "The most prominent change in this patch set is the software dirty bit
  patch for s390.  It removes __HAVE_ARCH_PAGE_TEST_AND_CLEAR_DIRTY and
  the page_test_and_clear_dirty primitive which makes the common memory
  management code a bit less obscure.

  Heiko fixed most of the PCI related fallout, more often than not
  missing GENERIC_HARDIRQS dependencies.  Notable is one of the 3270
  patches which adds an export to tty_io to be able to resize a tty.

  The rest is the usual bunch of cleanups and bug fixes."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux: (42 commits)
  s390/module: Add missing R_390_NONE relocation type
  drivers/gpio: add missing GENERIC_HARDIRQ dependency
  drivers/input: add couple of missing GENERIC_HARDIRQS dependencies
  s390/cleanup: rename SPP to LPP
  s390/mm: implement software dirty bits
  s390/mm: Fix crst upgrade of mmap with MAP_FIXED
  s390/linker skript: discard exit.data at runtime
  drivers/media: add missing GENERIC_HARDIRQS dependency
  s390/bpf,jit: add vlan tag support
  drivers/net,AT91RM9200: add missing GENERIC_HARDIRQS dependency
  iucv: fix kernel panic at reboot
  s390/Kconfig: sort list of arch selected config options
  phylib: remove !S390 dependeny from Kconfig
  uio: remove !S390 dependency from Kconfig
  dasd: fix sysfs cleanup in dasd_generic_remove
  s390/pci: fix hotplug module init
  s390/pci: cleanup clp page allocation
  s390/pci: cleanup clp inline assembly
  s390/perf: cpum_cf: fallback to software sampling events
  s390/mm: provide PAGE_SHARED define
  ...

7 files changed, 501 insertions, 416 deletions

diff --git a/drivers/s390/char/fs3270.c b/drivers/s390/char/fs3270.c
index 911704571b9c..230697aac94b 100644
--- a/drivers/s390/char/fs3270.c
+++ b/drivers/s390/char/fs3270.c
@@ -443,7 +443,7 @@ fs3270_open(struct inode *inode, struct file *filp)
                         tty_kref_put(tty);
                         return -ENODEV;
                 }
-                minor = tty->index + RAW3270_FIRSTMINOR;
+                minor = tty->index;
                 tty_kref_put(tty);
         }
         mutex_lock(&fs3270_mutex);
@@ -524,6 +524,25 @@ static const struct file_operations fs3270_fops = {
         .llseek         = no_llseek,
 };
 
+void fs3270_create_cb(int minor)
+{
+        __register_chrdev(IBM_FS3270_MAJOR, minor, 1, "tub", &fs3270_fops);
+        device_create(class3270, NULL, MKDEV(IBM_FS3270_MAJOR, minor),
+                      NULL, "3270/tub%d", minor);
+}
+
+void fs3270_destroy_cb(int minor)
+{
+        device_destroy(class3270, MKDEV(IBM_FS3270_MAJOR, minor));
+        __unregister_chrdev(IBM_FS3270_MAJOR, minor, 1, "tub");
+}
+
+struct raw3270_notifier fs3270_notifier =
+{
+        .create = fs3270_create_cb,
+        .destroy = fs3270_destroy_cb,
+};
+
 /*
  * 3270 fullscreen driver initialization.
  */
@@ -532,16 +551,20 @@ fs3270_init(void)
 {
         int rc;
 
-        rc = register_chrdev(IBM_FS3270_MAJOR, "fs3270", &fs3270_fops);
+        rc = __register_chrdev(IBM_FS3270_MAJOR, 0, 1, "fs3270", &fs3270_fops);
         if (rc)
                 return rc;
+        device_create(class3270, NULL, MKDEV(IBM_FS3270_MAJOR, 0),
+                      NULL, "3270/tub");
+        raw3270_register_notifier(&fs3270_notifier);
         return 0;
 }
 
 static void __exit
 fs3270_exit(void)
 {
-        unregister_chrdev(IBM_FS3270_MAJOR, "fs3270");
+        raw3270_unregister_notifier(&fs3270_notifier);
+        __unregister_chrdev(IBM_FS3270_MAJOR, 0, 1, "fs3270");
 }
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 9a6c140c5f07..4c9030a5b9f2 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -28,7 +28,7 @@
 #include <linux/device.h>
 #include <linux/mutex.h>
 
-static struct class *class3270;
+struct class *class3270;
 
 /* The main 3270 data structure. */
 struct raw3270 {
@@ -37,6 +37,7 @@ struct raw3270 {
         int minor;
 
         short model, rows, cols;
+        unsigned int state;
         unsigned long flags;
 
         struct list_head req_queue;     /* Request queue. */
@@ -46,20 +47,26 @@ struct raw3270 {
         struct timer_list timer;        /* Device timer. */
 
         unsigned char *ascebc;          /* ascii -> ebcdic table */
-        struct device *clttydev;        /* 3270-class tty device ptr */
-        struct device *cltubdev;        /* 3270-class tub device ptr */
 
-        struct raw3270_request init_request;
+        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_ATTN      2       /* Device sent an ATTN interrupt */
-#define RAW3270_FLAGS_READY     4       /* Device is useable by views */
-#define RAW3270_FLAGS_CONSOLE   8       /* Device is the console. */
-#define RAW3270_FLAGS_FROZEN    16      /* set if 3270 is frozen for suspend */
+#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);
@@ -97,6 +104,17 @@ static unsigned char raw3270_ebcgraf[64] =	{
         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)
 {
@@ -214,7 +232,7 @@ raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
  * Stop running ccw.
  */
 static int
-raw3270_halt_io_nolock(struct raw3270 *rp, struct raw3270_request *rq)
+__raw3270_halt_io(struct raw3270 *rp, struct raw3270_request *rq)
 {
         int retries;
         int rc;
@@ -233,18 +251,6 @@ raw3270_halt_io_nolock(struct raw3270 *rp, struct raw3270_request *rq)
         return rc;
 }
 
-static int
-raw3270_halt_io(struct raw3270 *rp, struct raw3270_request *rq)
-{
-        unsigned long flags;
-        int rc;
-
-        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
-        rc = raw3270_halt_io_nolock(rp, rq);
-        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
-        return rc;
-}
-
 /*
  * 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.
@@ -281,8 +287,8 @@ raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
         if (!rp || rp->view != view ||
             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                 rc = -EACCES;
-        else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
-                rc = -ENODEV;
+        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);
@@ -299,8 +305,8 @@ raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
         if (!rp || rp->view != view ||
             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                 rc = -EACCES;
-        else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
-                rc = -ENODEV;
+        else if (!raw3270_state_ready(rp))
+                rc = -EBUSY;
         else
                 rc =  __raw3270_start(rp, view, rq);
         return rc;
@@ -378,7 +384,7 @@ raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
         case RAW3270_IO_STOP:
                 if (!rq)
                         break;
-                raw3270_halt_io_nolock(rp, rq);
+                __raw3270_halt_io(rp, rq);
                 rq->rc = -EIO;
                 break;
         default:
@@ -413,9 +419,14 @@ raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
 }
 
 /*
- * Size sensing.
+ * 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 */
@@ -451,117 +462,21 @@ struct raw3270_ua {	/* Query Reply structure for Usable Area */
         } __attribute__ ((packed)) aua;
 } __attribute__ ((packed));
 
-static struct diag210 raw3270_init_diag210;
-static DEFINE_MUTEX(raw3270_init_mutex);
-
-static int
-raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
-                 struct irb *irb)
-{
-        /*
-         * Unit-Check Processing:
-         * Expect Command Reject or Intervention Required.
-         */
-        if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
-                /* Request finished abnormally. */
-                if (irb->ecw[0] & SNS0_INTERVENTION_REQ) {
-                        set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags);
-                        return RAW3270_IO_BUSY;
-                }
-        }
-        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;
-                } else
-                        /* Request finished normally. Copy residual count. */
-                        rq->rescnt = irb->scsw.cmd.count;
-        }
-        if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
-                set_bit(RAW3270_FLAGS_ATTN, &view->dev->flags);
-                wake_up(&raw3270_wait_queue);
-        }
-        return RAW3270_IO_DONE;
-}
-
-static struct raw3270_fn raw3270_init_fn = {
-        .intv = raw3270_init_irq
-};
-
-static struct raw3270_view raw3270_init_view = {
-        .fn = &raw3270_init_fn
-};
-
-/*
- * raw3270_wait/raw3270_wait_interruptible/__raw3270_wakeup
- * Wait for end of request. The request must have been started
- * with raw3270_start, rc = 0. The device lock may NOT have been
- * released between calling raw3270_start and raw3270_wait.
- */
 static void
-raw3270_wake_init(struct raw3270_request *rq, void *data)
-{
-        wake_up((wait_queue_head_t *) data);
-}
-
-/*
- * Special wait function that can cope with console initialization.
- */
-static int
-raw3270_start_init(struct raw3270 *rp, struct raw3270_view *view,
-                   struct raw3270_request *rq)
-{
-        unsigned long flags;
-        int rc;
-
-#ifdef CONFIG_TN3270_CONSOLE
-        if (raw3270_registered == 0) {
-                spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
-                rq->callback = NULL;
-                rc = __raw3270_start(rp, view, rq);
-                if (rc == 0)
-                        while (!raw3270_request_final(rq)) {
-                                wait_cons_dev();
-                                barrier();
-                        }
-                spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
-                return rq->rc;
-        }
-#endif
-        rq->callback = raw3270_wake_init;
-        rq->callback_data = &raw3270_wait_queue;
-        spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
-        rc = __raw3270_start(rp, view, rq);
-        spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
-        if (rc)
-                return rc;
-        /* Now wait for the completion. */
-        rc = wait_event_interruptible(raw3270_wait_queue,
-                                      raw3270_request_final(rq));
-        if (rc == -ERESTARTSYS) {       /* Interrupted by a signal. */
-                raw3270_halt_io(view->dev, rq);
-                /* No wait for the halt to complete. */
-                wait_event(raw3270_wait_queue, raw3270_request_final(rq));
-                return -ERESTARTSYS;
-        }
-        return rq->rc;
-}
-
-static int
-__raw3270_size_device_vm(struct raw3270 *rp)
+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);
-        raw3270_init_diag210.vrdcdvno = dev_id.devno;
-        raw3270_init_diag210.vrdclen = sizeof(struct diag210);
-        rc = diag210(&raw3270_init_diag210);
-        if (rc)
-                return rc;
-        model = raw3270_init_diag210.vrdccrmd;
+        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;
@@ -583,77 +498,25 @@ __raw3270_size_device_vm(struct raw3270 *rp)
                 rp->rows = 27;
                 rp->cols = 132;
                 break;
-        default:
-                rc = -EOPNOTSUPP;
-                break;
         }
-        return rc;
 }
 
-static int
-__raw3270_size_device(struct raw3270 *rp)
+static void
+raw3270_size_device(struct raw3270 *rp)
 {
-        static const unsigned char wbuf[] =
-                { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
         struct raw3270_ua *uap;
-        int rc;
 
-        /*
-         * 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').
-         */
-        memset(&rp->init_request, 0, sizeof(rp->init_request));
-        memset(&rp->init_data, 0, 256);
-        /* Store 'read partition' data stream to init_data */
-        memcpy(&rp->init_data, wbuf, sizeof(wbuf));
-        INIT_LIST_HEAD(&rp->init_request.list);
-        rp->init_request.ccw.cmd_code = TC_WRITESF;
-        rp->init_request.ccw.flags = CCW_FLAG_SLI;
-        rp->init_request.ccw.count = sizeof(wbuf);
-        rp->init_request.ccw.cda = (__u32) __pa(&rp->init_data);
-
-        rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
-        if (rc)
-                /* Check error cases: -ERESTARTSYS, -EIO and -EOPNOTSUPP */
-                return rc;
-
-        /* Wait for attention interrupt. */
-#ifdef CONFIG_TN3270_CONSOLE
-        if (raw3270_registered == 0) {
-                unsigned long flags;
-
-                spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
-                while (!test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags))
-                        wait_cons_dev();
-                spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
-        } else
-#endif
-                rc = wait_event_interruptible(raw3270_wait_queue,
-                        test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags));
-        if (rc)
-                return rc;
-
-        /*
-         * The device accepted the 'read partition' command. Now
-         * set up a read ccw and issue it.
-         */
-        rp->init_request.ccw.cmd_code = TC_READMOD;
-        rp->init_request.ccw.flags = CCW_FLAG_SLI;
-        rp->init_request.ccw.count = sizeof(rp->init_data);
-        rp->init_request.ccw.cda = (__u32) __pa(rp->init_data);
-        rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
-        if (rc)
-                return rc;
         /* Got a Query Reply */
         uap = (struct raw3270_ua *) (rp->init_data + 1);
         /* Paranoia check. */
-        if (rp->init_data[0] != 0x88 || uap->uab.qcode != 0x81)
-                return -EOPNOTSUPP;
+        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;
@@ -666,66 +529,131 @@ __raw3270_size_device(struct raw3270 *rp)
                 rp->rows = uap->aua.hauai;
                 rp->cols = uap->aua.wauai;
         }
-        return 0;
+        /* 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 int
-raw3270_size_device(struct raw3270 *rp)
+static void
+raw3270_size_device_done(struct raw3270 *rp)
 {
-        int rc;
+        struct raw3270_view *view;
 
-        mutex_lock(&raw3270_init_mutex);
-        rp->view = &raw3270_init_view;
-        raw3270_init_view.dev = rp;
-        if (MACHINE_IS_VM)
-                rc = __raw3270_size_device_vm(rp);
-        else
-                rc = __raw3270_size_device(rp);
-        raw3270_init_view.dev = NULL;
         rp->view = NULL;
-        mutex_unlock(&raw3270_init_mutex);
-        if (rc == 0) {  /* Found something. */
-                /* 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;
-        } else {
-                /* Couldn't detect size. Use default model 2. */
-                rp->model = 2;
-                rp->rows = 24;
-                rp->cols = 80;
-                return 0;
+        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;
         }
-        return rc;
+}
+
+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 && rq->rc) {
+                /* Reset command failed. */
+                rp->state = RAW3270_STATE_INIT;
+        } else if (0 && MACHINE_IS_VM) {
+                raw3270_size_device_vm(rp);
+                raw3270_size_device_done(rp);
+        } else
+                raw3270_writesf_readpart(rp);
 }
 
 static int
-raw3270_reset_device(struct raw3270 *rp)
+__raw3270_reset_device(struct raw3270 *rp)
 {
         int rc;
 
-        mutex_lock(&raw3270_init_mutex);
-        memset(&rp->init_request, 0, sizeof(rp->init_request));
+        /* Store reset data stream to init_data/init_reset */
+        memset(&rp->init_reset, 0, sizeof(rp->init_reset));
         memset(&rp->init_data, 0, sizeof(rp->init_data));
-        /* Store reset data stream to init_data/init_request */
         rp->init_data[0] = TW_KR;
-        INIT_LIST_HEAD(&rp->init_request.list);
-        rp->init_request.ccw.cmd_code = TC_EWRITEA;
-        rp->init_request.ccw.flags = CCW_FLAG_SLI;
-        rp->init_request.ccw.count = 1;
-        rp->init_request.ccw.cda = (__u32) __pa(rp->init_data);
-        rp->view = &raw3270_init_view;
-        raw3270_init_view.dev = rp;
-        rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
-        raw3270_init_view.dev = NULL;
-        rp->view = NULL;
-        mutex_unlock(&raw3270_init_mutex);
+        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;
 }
 
@@ -739,13 +667,50 @@ raw3270_reset(struct raw3270_view *view)
         if (!rp || rp->view != view ||
             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                 rc = -EACCES;
-        else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
-                rc = -ENODEV;
+        else if (!raw3270_state_ready(rp))
+                rc = -EBUSY;
         else
                 rc = raw3270_reset_device(view->dev);
         return rc;
 }
 
+static int
+raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
+                 struct irb *irb)
+{
+        struct raw3270 *rp;
+
+        /*
+         * Unit-Check Processing:
+         * Expect Command Reject or Intervention Required.
+         */
+        if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
+                /* Request finished abnormally. */
+                if (irb->ecw[0] & SNS0_INTERVENTION_REQ) {
+                        set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags);
+                        return RAW3270_IO_BUSY;
+                }
+        }
+        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);
+        }
+        return RAW3270_IO_DONE;
+}
+
+static struct raw3270_fn raw3270_init_fn = {
+        .intv = raw3270_init_irq
+};
+
 /*
  * Setup new 3270 device.
  */
@@ -774,6 +739,10 @@ raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
         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,
@@ -812,6 +781,7 @@ raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
  */
 struct raw3270 __init *raw3270_setup_console(struct ccw_device *cdev)
 {
+        unsigned long flags;
         struct raw3270 *rp;
         char *ascebc;
         int rc;
@@ -822,16 +792,15 @@ struct raw3270 __init *raw3270_setup_console(struct ccw_device *cdev)
         if (rc)
                 return ERR_PTR(rc);
         set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
-        rc = raw3270_reset_device(rp);
-        if (rc)
-                return ERR_PTR(rc);
-        rc = raw3270_size_device(rp);
-        if (rc)
-                return ERR_PTR(rc);
-        rc = raw3270_reset_device(rp);
-        if (rc)
-                return ERR_PTR(rc);
-        set_bit(RAW3270_FLAGS_READY, &rp->flags);
+        spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
+        do {
+                __raw3270_reset_device(rp);
+                while (!raw3270_state_final(rp)) {
+                        wait_cons_dev();
+                        barrier();
+                }
+        } while (rp->state != RAW3270_STATE_READY);
+        spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
         return rp;
 }
 
@@ -893,13 +862,13 @@ raw3270_activate_view(struct raw3270_view *view)
         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
         if (rp->view == view)
                 rc = 0;
-        else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
-                rc = -ENODEV;
+        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) {
+                if (rp->view && rp->view->fn->deactivate) {
                         oldview = rp->view;
                         oldview->fn->deactivate(oldview);
                 }
@@ -944,7 +913,7 @@ raw3270_deactivate_view(struct raw3270_view *view)
                 list_del_init(&view->list);
                 list_add_tail(&view->list, &rp->view_list);
                 /* Try to activate another view. */
-                if (test_bit(RAW3270_FLAGS_READY, &rp->flags) &&
+                if (raw3270_state_ready(rp) &&
                     !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
                         list_for_each_entry(view, &rp->view_list, list) {
                                 rp->view = view;
@@ -975,18 +944,16 @@ raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
                 if (rp->minor != minor)
                         continue;
                 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
-                if (test_bit(RAW3270_FLAGS_READY, &rp->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);
-                        list_add(&view->list, &rp->view_list);
-                        rc = 0;
-                }
+                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);
+                list_add(&view->list, &rp->view_list);
+                rc = 0;
                 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
                 break;
         }
@@ -1010,14 +977,11 @@ raw3270_find_view(struct raw3270_fn *fn, int minor)
                 if (rp->minor != minor)
                         continue;
                 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
-                if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
-                        view = ERR_PTR(-ENOENT);
-                        list_for_each_entry(tmp, &rp->view_list, list) {
-                                if (tmp->fn == fn) {
-                                        raw3270_get_view(tmp);
-                                        view = tmp;
-                                        break;
-                                }
+                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);
@@ -1044,7 +1008,7 @@ raw3270_del_view(struct raw3270_view *view)
                 rp->view = NULL;
         }
         list_del_init(&view->list);
-        if (!rp->view && test_bit(RAW3270_FLAGS_READY, &rp->flags) &&
+        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) {
@@ -1072,10 +1036,6 @@ raw3270_delete_device(struct raw3270 *rp)
 
         /* Remove from device chain. */
         mutex_lock(&raw3270_mutex);
-        if (rp->clttydev && !IS_ERR(rp->clttydev))
-                device_destroy(class3270, MKDEV(IBM_TTY3270_MAJOR, rp->minor));
-        if (rp->cltubdev && !IS_ERR(rp->cltubdev))
-                device_destroy(class3270, MKDEV(IBM_FS3270_MAJOR, rp->minor));
         list_del_init(&rp->list);
         mutex_unlock(&raw3270_mutex);
 
@@ -1139,75 +1099,34 @@ static struct attribute_group raw3270_attr_group = {
 
 static int raw3270_create_attributes(struct raw3270 *rp)
 {
-        int rc;
-
-        rc = sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
-        if (rc)
-                goto out;
-
-        rp->clttydev = device_create(class3270, &rp->cdev->dev,
-                                     MKDEV(IBM_TTY3270_MAJOR, rp->minor), NULL,
-                                     "tty%s", dev_name(&rp->cdev->dev));
-        if (IS_ERR(rp->clttydev)) {
-                rc = PTR_ERR(rp->clttydev);
-                goto out_ttydev;
-        }
-
-        rp->cltubdev = device_create(class3270, &rp->cdev->dev,
-                                     MKDEV(IBM_FS3270_MAJOR, rp->minor), NULL,
-                                     "tub%s", dev_name(&rp->cdev->dev));
-        if (!IS_ERR(rp->cltubdev))
-                goto out;
-
-        rc = PTR_ERR(rp->cltubdev);
-        device_destroy(class3270, MKDEV(IBM_TTY3270_MAJOR, rp->minor));
-
-out_ttydev:
-        sysfs_remove_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
-out:
-        return rc;
+        return sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
 }
 
 /*
  * Notifier for device addition/removal
  */
-struct raw3270_notifier {
-        struct list_head list;
-        void (*notifier)(int, int);
-};
-
 static LIST_HEAD(raw3270_notifier);
 
-int raw3270_register_notifier(void (*notifier)(int, int))
+int raw3270_register_notifier(struct raw3270_notifier *notifier)
 {
-        struct raw3270_notifier *np;
         struct raw3270 *rp;
 
-        np = kmalloc(sizeof(struct raw3270_notifier), GFP_KERNEL);
-        if (!np)
-                return -ENOMEM;
-        np->notifier = notifier;
         mutex_lock(&raw3270_mutex);
-        list_add_tail(&np->list, &raw3270_notifier);
-        list_for_each_entry(rp, &raw3270_devices, list) {
-                get_device(&rp->cdev->dev);
-                notifier(rp->minor, 1);
-        }
+        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(void (*notifier)(int, int))
+void raw3270_unregister_notifier(struct raw3270_notifier *notifier)
 {
-        struct raw3270_notifier *np;
+        struct raw3270 *rp;
 
         mutex_lock(&raw3270_mutex);
-        list_for_each_entry(np, &raw3270_notifier, list)
-                if (np->notifier == notifier) {
-                        list_del(&np->list);
-                        kfree(np);
-                        break;
-                }
+        list_for_each_entry(rp, &raw3270_devices, list)
+                notifier->destroy(rp->minor);
+        list_del(&notifier->list);
         mutex_unlock(&raw3270_mutex);
 }
 
@@ -1217,29 +1136,20 @@ void raw3270_unregister_notifier(void (*notifier)(int, int))
 static int
 raw3270_set_online (struct ccw_device *cdev)
 {
-        struct raw3270 *rp;
         struct raw3270_notifier *np;
+        struct raw3270 *rp;
         int rc;
 
         rp = raw3270_create_device(cdev);
         if (IS_ERR(rp))
                 return PTR_ERR(rp);
-        rc = raw3270_reset_device(rp);
-        if (rc)
-                goto failure;
-        rc = raw3270_size_device(rp);
-        if (rc)
-                goto failure;
-        rc = raw3270_reset_device(rp);
-        if (rc)
-                goto failure;
         rc = raw3270_create_attributes(rp);
         if (rc)
                 goto failure;
-        set_bit(RAW3270_FLAGS_READY, &rp->flags);
+        raw3270_reset_device(rp);
         mutex_lock(&raw3270_mutex);
         list_for_each_entry(np, &raw3270_notifier, list)
-                np->notifier(rp->minor, 1);
+                np->create(rp->minor);
         mutex_unlock(&raw3270_mutex);
         return 0;
 
@@ -1268,14 +1178,14 @@ raw3270_remove (struct ccw_device *cdev)
          */
         if (rp == NULL)
                 return;
-        clear_bit(RAW3270_FLAGS_READY, &rp->flags);
 
         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) {
-                rp->view->fn->deactivate(rp->view);
+                if (rp->view->fn->deactivate)
+                        rp->view->fn->deactivate(rp->view);
                 rp->view = NULL;
         }
         while (!list_empty(&rp->view_list)) {
@@ -1290,7 +1200,7 @@ raw3270_remove (struct ccw_device *cdev)
 
         mutex_lock(&raw3270_mutex);
         list_for_each_entry(np, &raw3270_notifier, list)
-                np->notifier(rp->minor, 0);
+                np->destroy(rp->minor);
         mutex_unlock(&raw3270_mutex);
 
         /* Reset 3270 device. */
@@ -1324,7 +1234,7 @@ static int raw3270_pm_stop(struct ccw_device *cdev)
         if (!rp)
                 return 0;
         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
-        if (rp->view)
+        if (rp->view && rp->view->fn->deactivate)
                 rp->view->fn->deactivate(rp->view);
         if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
                 /*
@@ -1351,7 +1261,7 @@ static int raw3270_pm_start(struct ccw_device *cdev)
                 return 0;
         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
         clear_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
-        if (rp->view)
+        if (rp->view && rp->view->fn->activate)
                 rp->view->fn->activate(rp->view);
         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
         return 0;
@@ -1434,6 +1344,7 @@ 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);
diff --git a/drivers/s390/char/raw3270.h b/drivers/s390/char/raw3270.h
index ed34eb2199cc..7b73ff8c1bd7 100644
--- a/drivers/s390/char/raw3270.h
+++ b/drivers/s390/char/raw3270.h
@@ -91,6 +91,7 @@ struct raw3270_iocb {
 
 struct raw3270;
 struct raw3270_view;
+extern struct class *class3270;
 
 /* 3270 CCW request */
 struct raw3270_request {
@@ -140,6 +141,7 @@ struct raw3270_fn {
                      struct raw3270_request *, struct irb *);
         void (*release)(struct raw3270_view *);
         void (*free)(struct raw3270_view *);
+        void (*resize)(struct raw3270_view *, int, int, int);
 };
 
 /*
@@ -192,8 +194,14 @@ struct raw3270 *raw3270_setup_console(struct ccw_device *cdev);
 void raw3270_wait_cons_dev(struct raw3270 *);
 
 /* Notifier for device addition/removal */
-int raw3270_register_notifier(void (*notifier)(int, int));
-void raw3270_unregister_notifier(void (*notifier)(int, int));
+struct raw3270_notifier {
+        struct list_head list;
+        void (*create)(int minor);
+        void (*destroy)(int minor);
+};
+
+int raw3270_register_notifier(struct raw3270_notifier *);
+void raw3270_unregister_notifier(struct raw3270_notifier *);
 void raw3270_pm_unfreeze(struct raw3270_view *);
 
 /*
diff --git a/drivers/s390/char/sclp.c b/drivers/s390/char/sclp.c
index 12c16a65dd25..bd6871bf545a 100644
--- a/drivers/s390/char/sclp.c
+++ b/drivers/s390/char/sclp.c
@@ -450,7 +450,7 @@ sclp_sync_wait(void)
         timeout = 0;
         if (timer_pending(&sclp_request_timer)) {
                 /* Get timeout TOD value */
-                timeout = get_clock() +
+                timeout = get_tod_clock() +
                           sclp_tod_from_jiffies(sclp_request_timer.expires -
                                                 jiffies);
         }
@@ -472,7 +472,7 @@ sclp_sync_wait(void)
         while (sclp_running_state != sclp_running_state_idle) {
                 /* Check for expired request timer */
                 if (timer_pending(&sclp_request_timer) &&
-                    get_clock() > timeout &&
+                    get_tod_clock() > timeout &&
                     del_timer(&sclp_request_timer))
                         sclp_request_timer.function(sclp_request_timer.data);
                 cpu_relax();
diff --git a/drivers/s390/char/sclp_cmd.c b/drivers/s390/char/sclp_cmd.c
index c44d13f607bc..30a2255389e5 100644
--- a/drivers/s390/char/sclp_cmd.c
+++ b/drivers/s390/char/sclp_cmd.c
@@ -56,7 +56,6 @@ static int __initdata early_read_info_sccb_valid;
 
 u64 sclp_facilities;
 static u8 sclp_fac84;
-static u8 sclp_fac85;
 static unsigned long long rzm;
 static unsigned long long rnmax;
 
@@ -131,7 +130,8 @@ void __init sclp_facilities_detect(void)
         sccb = &early_read_info_sccb;
         sclp_facilities = sccb->facilities;
         sclp_fac84 = sccb->fac84;
-        sclp_fac85 = sccb->fac85;
+        if (sccb->fac85 & 0x02)
+                S390_lowcore.machine_flags |= MACHINE_FLAG_ESOP;
         rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2;
         rzm = sccb->rnsize ? sccb->rnsize : sccb->rnsize2;
         rzm <<= 20;
@@ -171,12 +171,6 @@ unsigned long long sclp_get_rzm(void)
         return rzm;
 }
 
-u8 sclp_get_fac85(void)
-{
-        return sclp_fac85;
-}
-EXPORT_SYMBOL_GPL(sclp_get_fac85);
-
 /*
  * This function will be called after sclp_facilities_detect(), which gets
  * called from early.c code. Therefore the sccb should have valid contents.
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index 3860e796b65f..b907dba24025 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/interrupt.h>
+#include <linux/workqueue.h>
 
 #include <linux/slab.h>
 #include <linux/bootmem.h>
@@ -80,6 +81,8 @@ struct tty3270 {
         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. */
@@ -115,6 +118,7 @@ struct tty3270 {
 #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.
@@ -683,12 +687,6 @@ tty3270_alloc_view(void)
         INIT_LIST_HEAD(&tp->update);
         INIT_LIST_HEAD(&tp->rcl_lines);
         tp->rcl_max = 20;
-        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);
 
         for (pages = 0; pages < TTY3270_STRING_PAGES; pages++) {
                 tp->freemem_pages[pages] = (void *)
@@ -710,6 +708,15 @@ tty3270_alloc_view(void)
         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:
@@ -752,42 +759,96 @@ tty3270_free_view(struct tty3270 *tp)
 /*
  * Allocate tty3270 screen.
  */
-static int
-tty3270_alloc_screen(struct tty3270 *tp)
+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) * (tp->view.rows - 2);
-        tp->screen = kzalloc(size, GFP_KERNEL);
-        if (!tp->screen)
+        size = sizeof(struct tty3270_line) * (rows - 2);
+        screen = kzalloc(size, GFP_KERNEL);
+        if (!screen)
                 goto out_err;
-        for (lines = 0; lines < tp->view.rows - 2; lines++) {
-                size = sizeof(struct tty3270_cell) * tp->view.cols;
-                tp->screen[lines].cells = kzalloc(size, GFP_KERNEL);
-                if (!tp->screen[lines].cells)
+        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 0;
+        return screen;
 out_screen:
         while (lines--)
-                kfree(tp->screen[lines].cells);
-        kfree(tp->screen);
+                kfree(screen[lines].cells);
+        kfree(screen);
 out_err:
-        return -ENOMEM;
+        return ERR_PTR(-ENOMEM);
 }
 
 /*
  * Free tty3270 screen.
  */
 static void
-tty3270_free_screen(struct tty3270 *tp)
+tty3270_free_screen(struct tty3270_line *screen, unsigned int rows)
 {
         int lines;
 
-        for (lines = 0; lines < tp->view.rows - 2; lines++)
-                kfree(tp->screen[lines].cells);
-        kfree(tp->screen);
+        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);
 }
 
 /*
@@ -815,7 +876,8 @@ static void
 tty3270_free(struct raw3270_view *view)
 {
         struct tty3270 *tp = container_of(view, struct tty3270, view);
-        tty3270_free_screen(tp);
+
+        tty3270_free_screen(tp->screen, tp->view.rows);
         tty3270_free_view(tp);
 }
 
@@ -827,9 +889,8 @@ tty3270_del_views(void)
 {
         int i;
 
-        for (i = 0; i < tty3270_max_index; i++) {
-                struct raw3270_view *view =
-                        raw3270_find_view(&tty3270_fn, i + RAW3270_FIRSTMINOR);
+        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);
         }
@@ -840,7 +901,8 @@ static struct raw3270_fn tty3270_fn = {
         .deactivate = tty3270_deactivate,
         .intv = (void *) tty3270_irq,
         .release = tty3270_release,
-        .free = tty3270_free
+        .free = tty3270_free,
+        .resize = tty3270_resize
 };
 
 /*
@@ -853,8 +915,7 @@ static int tty3270_install(struct tty_driver *driver, struct tty_struct *tty)
         int i, rc;
 
         /* Check if the tty3270 is already there. */
-        view = raw3270_find_view(&tty3270_fn,
-                                  tty->index + RAW3270_FIRSTMINOR);
+        view = raw3270_find_view(&tty3270_fn, tty->index);
         if (!IS_ERR(view)) {
                 tp = container_of(view, struct tty3270, view);
                 tty->driver_data = tp;
@@ -866,29 +927,26 @@ static int tty3270_install(struct tty_driver *driver, struct tty_struct *tty)
                 tp->inattr = TF_INPUT;
                 return tty_port_install(&tp->port, driver, tty);
         }
-        if (tty3270_max_index < tty->index + 1)
-                tty3270_max_index = tty->index + 1;
-
-        /* Quick exit if there is no device for tty->index. */
-        if (PTR_ERR(view) == -ENODEV)
-                return -ENODEV;
+        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 + RAW3270_FIRSTMINOR);
+        rc = raw3270_add_view(&tp->view, &tty3270_fn, tty->index);
         if (rc) {
                 tty3270_free_view(tp);
                 return rc;
         }
 
-        rc = tty3270_alloc_screen(tp);
-        if (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;
         }
 
@@ -926,6 +984,20 @@ static int tty3270_install(struct tty_driver *driver, struct tty_struct *tty)
 }
 
 /*
+ * 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.
  */
@@ -1753,6 +1825,7 @@ static long tty3270_compat_ioctl(struct tty_struct *tty,
 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,
@@ -1771,6 +1844,22 @@ static const struct tty_operations tty3270_ops = {
         .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.
@@ -1780,23 +1869,25 @@ static int __init tty3270_init(void)
         struct tty_driver *driver;
         int ret;
 
-        driver = alloc_tty_driver(RAW3270_MAXDEVS);
-        if (!driver)
-                return -ENOMEM;
+        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 = "ttyTUB";
-        driver->name = "ttyTUB";
+        driver->driver_name = "tty3270";
+        driver->name = "3270/tty";
         driver->major = IBM_TTY3270_MAJOR;
-        driver->minor_start = RAW3270_FIRSTMINOR;
+        driver->minor_start = 0;
         driver->type = TTY_DRIVER_TYPE_SYSTEM;
         driver->subtype = SYSTEM_TYPE_TTY;
         driver->init_termios = tty_std_termios;
-        driver->flags = TTY_DRIVER_RESET_TERMIOS;
         tty_set_operations(driver, &tty3270_ops);
         ret = tty_register_driver(driver);
         if (ret) {
@@ -1804,6 +1895,7 @@ static int __init tty3270_init(void)
                 return ret;
         }
         tty3270_driver = driver;
+        raw3270_register_notifier(&tty3270_notifier);
         return 0;
 }
 
@@ -1812,6 +1904,7 @@ tty3270_exit(void)
 {
         struct tty_driver *driver;
 
+        raw3270_unregister_notifier(&tty3270_notifier);
         driver = tty3270_driver;
         tty3270_driver = NULL;
         tty_unregister_driver(driver);
diff --git a/drivers/s390/char/zcore.c b/drivers/s390/char/zcore.c
index e3b9308b0fe3..1d61a01576d2 100644
--- a/drivers/s390/char/zcore.c
+++ b/drivers/s390/char/zcore.c
@@ -62,6 +62,7 @@ static struct dentry *zcore_dir;
 static struct dentry *zcore_file;
 static struct dentry *zcore_memmap_file;
 static struct dentry *zcore_reipl_file;
+static struct dentry *zcore_hsa_file;
 static struct ipl_parameter_block *ipl_block;
 
 /*
@@ -77,6 +78,8 @@ static int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode)
         int offs, blk_num;
         static char buf[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
 
+        if (!hsa_available)
+                return -ENODATA;
         if (count == 0)
                 return 0;
 
@@ -278,6 +281,15 @@ next:
 }
 
 /*
+ * Release the HSA
+ */
+static void release_hsa(void)
+{
+        diag308(DIAG308_REL_HSA, NULL);
+        hsa_available = 0;
+}
+
+/*
  * Read routine for zcore character device
  * First 4K are dump header
  * Next 32MB are HSA Memory
@@ -363,8 +375,8 @@ static int zcore_open(struct inode *inode, struct file *filp)
 
 static int zcore_release(struct inode *inode, struct file *filep)
 {
-        diag308(DIAG308_REL_HSA, NULL);
-        hsa_available = 0;
+        if (hsa_available)
+                release_hsa();
         return 0;
 }
 
@@ -474,6 +486,41 @@ static const struct file_operations zcore_reipl_fops = {
         .llseek         = no_llseek,
 };
 
+static ssize_t zcore_hsa_read(struct file *filp, char __user *buf,
+                              size_t count, loff_t *ppos)
+{
+        static char str[18];
+
+        if (hsa_available)
+                snprintf(str, sizeof(str), "%lx\n", ZFCPDUMP_HSA_SIZE);
+        else
+                snprintf(str, sizeof(str), "0\n");
+        return simple_read_from_buffer(buf, count, ppos, str, strlen(str));
+}
+
+static ssize_t zcore_hsa_write(struct file *filp, const char __user *buf,
+                               size_t count, loff_t *ppos)
+{
+        char value;
+
+        if (*ppos != 0)
+                return -EPIPE;
+        if (copy_from_user(&value, buf, 1))
+                return -EFAULT;
+        if (value != '0')
+                return -EINVAL;
+        release_hsa();
+        return count;
+}
+
+static const struct file_operations zcore_hsa_fops = {
+        .owner          = THIS_MODULE,
+        .write          = zcore_hsa_write,
+        .read           = zcore_hsa_read,
+        .open           = nonseekable_open,
+        .llseek         = no_llseek,
+};
+
 #ifdef CONFIG_32BIT
 
 static void __init set_lc_mask(struct save_area *map)
@@ -590,7 +637,7 @@ static int __init zcore_header_init(int arch, struct zcore_header *hdr)
         hdr->rmem_size = memory;
         hdr->mem_end = sys_info.mem_size;
         hdr->num_pages = memory / PAGE_SIZE;
-        hdr->tod = get_clock();
+        hdr->tod = get_tod_clock();
         get_cpu_id(&hdr->cpu_id);
         for (i = 0; zfcpdump_save_areas[i]; i++) {
                 prefix = zfcpdump_save_areas[i]->pref_reg;
@@ -658,6 +705,7 @@ static int __init zcore_init(void)
         rc = check_sdias();
         if (rc)
                 goto fail;
+        hsa_available = 1;
 
         rc = memcpy_hsa_kernel(&arch, __LC_AR_MODE_ID, 1);
         if (rc)
@@ -714,9 +762,16 @@ static int __init zcore_init(void)
                 rc = -ENOMEM;
                 goto fail_memmap_file;
         }
-        hsa_available = 1;
+        zcore_hsa_file = debugfs_create_file("hsa", S_IRUSR|S_IWUSR, zcore_dir,
+                                             NULL, &zcore_hsa_fops);
+        if (!zcore_hsa_file) {
+                rc = -ENOMEM;
+                goto fail_reipl_file;
+        }
         return 0;
 
+fail_reipl_file:
+        debugfs_remove(zcore_reipl_file);
 fail_memmap_file:
         debugfs_remove(zcore_memmap_file);
 fail_file:
@@ -733,6 +788,7 @@ static void __exit zcore_exit(void)
         debug_unregister(zcore_dbf);
         sclp_sdias_exit();
         free_page((unsigned long) ipl_block);
+        debugfs_remove(zcore_hsa_file);
         debugfs_remove(zcore_reipl_file);
         debugfs_remove(zcore_memmap_file);
         debugfs_remove(zcore_file);