5 files changed, 431 insertions, 0 deletions

diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 3781db22f427..3f42161d6bc6 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -440,6 +440,17 @@ config SCM_BUS
         help
           Bus driver for Storage Class Memory.
 
+config EADM_SCH
+        def_tristate m
+        prompt "Support for EADM subchannels"
+        depends on SCM_BUS
+        help
+          This driver allows usage of EADM subchannels. EADM subchannels act
+          as a communication vehicle for SCM increments.
+
+          To compile this driver as a module, choose M here: the
+          module will be called eadm_sch.
+
 endmenu
 
 menu "Dump support"
diff --git a/arch/s390/include/asm/isc.h b/arch/s390/include/asm/isc.h
index 1420a1115948..5ae606456b0a 100644
--- a/arch/s390/include/asm/isc.h
+++ b/arch/s390/include/asm/isc.h
@@ -14,6 +14,7 @@
 /* Regular I/O interrupts. */
 #define IO_SCH_ISC 3                    /* regular I/O subchannels */
 #define CONSOLE_ISC 1                   /* console I/O subchannel */
+#define EADM_SCH_ISC 4                  /* EADM subchannels */
 #define CHSC_SCH_ISC 7                  /* CHSC subchannels */
 /* Adapter interrupts. */
 #define QDIO_AIRQ_ISC IO_SCH_ISC        /* I/O subchannel in qdio mode */
diff --git a/drivers/s390/cio/Makefile b/drivers/s390/cio/Makefile
index ac8f210e9a8f..8c4a386e97f6 100644
--- a/drivers/s390/cio/Makefile
+++ b/drivers/s390/cio/Makefile
@@ -8,6 +8,7 @@ ccw_device-objs += device.o device_fsm.o device_ops.o
 ccw_device-objs += device_id.o device_pgid.o device_status.o
 obj-y += ccw_device.o cmf.o
 obj-$(CONFIG_CHSC_SCH) += chsc_sch.o
+obj-$(CONFIG_EADM_SCH) += eadm_sch.o
 obj-$(CONFIG_SCM_BUS) += scm.o
 obj-$(CONFIG_CCWGROUP) += ccwgroup.o
 
diff --git a/drivers/s390/cio/eadm_sch.c b/drivers/s390/cio/eadm_sch.c
new file mode 100644
index 000000000000..3fc882f66689
--- /dev/null
+++ b/drivers/s390/cio/eadm_sch.c
@@ -0,0 +1,398 @@
+/*
+ * Driver for s390 eadm subchannels
+ *
+ * Copyright IBM Corp. 2012
+ * Author(s): Sebastian Ott <sebott@linux.vnet.ibm.com>
+ */
+
+#include <linux/workqueue.h>
+#include <linux/spinlock.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/timer.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+
+#include <asm/css_chars.h>
+#include <asm/debug.h>
+#include <asm/isc.h>
+#include <asm/cio.h>
+#include <asm/scsw.h>
+#include <asm/eadm.h>
+
+#include "eadm_sch.h"
+#include "ioasm.h"
+#include "cio.h"
+#include "css.h"
+#include "orb.h"
+
+MODULE_DESCRIPTION("driver for s390 eadm subchannels");
+MODULE_LICENSE("GPL");
+
+#define EADM_TIMEOUT (5 * HZ)
+static DEFINE_SPINLOCK(list_lock);
+static LIST_HEAD(eadm_list);
+
+static debug_info_t *eadm_debug;
+
+#define EADM_LOG(imp, txt) do {                                 \
+                debug_text_event(eadm_debug, imp, txt);         \
+        } while (0)
+
+static void EADM_LOG_HEX(int level, void *data, int length)
+{
+        if (level > eadm_debug->level)
+                return;
+        while (length > 0) {
+                debug_event(eadm_debug, level, data, length);
+                length -= eadm_debug->buf_size;
+                data += eadm_debug->buf_size;
+        }
+}
+
+static void orb_init(union orb *orb)
+{
+        memset(orb, 0, sizeof(union orb));
+        orb->eadm.compat1 = 1;
+        orb->eadm.compat2 = 1;
+        orb->eadm.fmt = 1;
+        orb->eadm.x = 1;
+}
+
+static int eadm_subchannel_start(struct subchannel *sch, struct aob *aob)
+{
+        union orb *orb = &get_eadm_private(sch)->orb;
+        int cc;
+
+        orb_init(orb);
+        orb->eadm.aob = (u32)__pa(aob);
+        orb->eadm.intparm = (u32)(addr_t)sch;
+        orb->eadm.key = PAGE_DEFAULT_KEY >> 4;
+
+        EADM_LOG(6, "start");
+        EADM_LOG_HEX(6, &sch->schid, sizeof(sch->schid));
+
+        cc = ssch(sch->schid, orb);
+        switch (cc) {
+        case 0:
+                sch->schib.scsw.eadm.actl |= SCSW_ACTL_START_PEND;
+                break;
+        case 1:         /* status pending */
+        case 2:         /* busy */
+                return -EBUSY;
+        case 3:         /* not operational */
+                return -ENODEV;
+        }
+        return 0;
+}
+
+static int eadm_subchannel_clear(struct subchannel *sch)
+{
+        int cc;
+
+        cc = csch(sch->schid);
+        if (cc)
+                return -ENODEV;
+
+        sch->schib.scsw.eadm.actl |= SCSW_ACTL_CLEAR_PEND;
+        return 0;
+}
+
+static void eadm_subchannel_timeout(unsigned long data)
+{
+        struct subchannel *sch = (struct subchannel *) data;
+
+        spin_lock_irq(sch->lock);
+        EADM_LOG(1, "timeout");
+        EADM_LOG_HEX(1, &sch->schid, sizeof(sch->schid));
+        if (eadm_subchannel_clear(sch))
+                EADM_LOG(0, "clear failed");
+        spin_unlock_irq(sch->lock);
+}
+
+static void eadm_subchannel_set_timeout(struct subchannel *sch, int expires)
+{
+        struct eadm_private *private = get_eadm_private(sch);
+
+        if (expires == 0) {
+                del_timer(&private->timer);
+                return;
+        }
+        if (timer_pending(&private->timer)) {
+                if (mod_timer(&private->timer, jiffies + expires))
+                        return;
+        }
+        private->timer.function = eadm_subchannel_timeout;
+        private->timer.data = (unsigned long) sch;
+        private->timer.expires = jiffies + expires;
+        add_timer(&private->timer);
+}
+
+static void eadm_subchannel_irq(struct subchannel *sch)
+{
+        struct eadm_private *private = get_eadm_private(sch);
+        struct eadm_scsw *scsw = &sch->schib.scsw.eadm;
+        struct irb *irb = (struct irb *)&S390_lowcore.irb;
+        int error = 0;
+
+        EADM_LOG(6, "irq");
+        EADM_LOG_HEX(6, irb, sizeof(*irb));
+
+        if ((scsw->stctl & (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND))
+            && scsw->eswf == 1 && irb->esw.eadm.erw.r)
+                error = -EIO;
+
+        if (scsw->fctl & SCSW_FCTL_CLEAR_FUNC)
+                error = -ETIMEDOUT;
+
+        eadm_subchannel_set_timeout(sch, 0);
+
+        if (private->state != EADM_BUSY) {
+                EADM_LOG(1, "irq unsol");
+                EADM_LOG_HEX(1, irb, sizeof(*irb));
+                private->state = EADM_NOT_OPER;
+                css_sched_sch_todo(sch, SCH_TODO_EVAL);
+                return;
+        }
+        scm_irq_handler((struct aob *)(unsigned long)scsw->aob, error);
+        private->state = EADM_IDLE;
+}
+
+static struct subchannel *eadm_get_idle_sch(void)
+{
+        struct eadm_private *private;
+        struct subchannel *sch;
+        unsigned long flags;
+
+        spin_lock_irqsave(&list_lock, flags);
+        list_for_each_entry(private, &eadm_list, head) {
+                sch = private->sch;
+                spin_lock(sch->lock);
+                if (private->state == EADM_IDLE) {
+                        private->state = EADM_BUSY;
+                        list_move_tail(&private->head, &eadm_list);
+                        spin_unlock(sch->lock);
+                        spin_unlock_irqrestore(&list_lock, flags);
+
+                        return sch;
+                }
+                spin_unlock(sch->lock);
+        }
+        spin_unlock_irqrestore(&list_lock, flags);
+
+        return NULL;
+}
+
+static int eadm_start_aob(struct aob *aob)
+{
+        struct eadm_private *private;
+        struct subchannel *sch;
+        unsigned long flags;
+        int ret;
+
+        sch = eadm_get_idle_sch();
+        if (!sch)
+                return -EBUSY;
+
+        spin_lock_irqsave(sch->lock, flags);
+        eadm_subchannel_set_timeout(sch, EADM_TIMEOUT);
+        ret = eadm_subchannel_start(sch, aob);
+        if (!ret)
+                goto out_unlock;
+
+        /* Handle start subchannel failure. */
+        eadm_subchannel_set_timeout(sch, 0);
+        private = get_eadm_private(sch);
+        private->state = EADM_NOT_OPER;
+        css_sched_sch_todo(sch, SCH_TODO_EVAL);
+
+out_unlock:
+        spin_unlock_irqrestore(sch->lock, flags);
+
+        return ret;
+}
+
+static int eadm_subchannel_probe(struct subchannel *sch)
+{
+        struct eadm_private *private;
+        int ret;
+
+        private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA);
+        if (!private)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&private->head);
+        init_timer(&private->timer);
+
+        spin_lock_irq(sch->lock);
+        set_eadm_private(sch, private);
+        private->state = EADM_IDLE;
+        private->sch = sch;
+        sch->isc = EADM_SCH_ISC;
+        ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch);
+        if (ret) {
+                set_eadm_private(sch, NULL);
+                spin_unlock_irq(sch->lock);
+                kfree(private);
+                goto out;
+        }
+        spin_unlock_irq(sch->lock);
+
+        spin_lock_irq(&list_lock);
+        list_add(&private->head, &eadm_list);
+        spin_unlock_irq(&list_lock);
+
+        if (dev_get_uevent_suppress(&sch->dev)) {
+                dev_set_uevent_suppress(&sch->dev, 0);
+                kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
+        }
+out:
+        return ret;
+}
+
+static void eadm_quiesce(struct subchannel *sch)
+{
+        int ret;
+
+        do {
+                spin_lock_irq(sch->lock);
+                ret = cio_disable_subchannel(sch);
+                spin_unlock_irq(sch->lock);
+        } while (ret == -EBUSY);
+}
+
+static int eadm_subchannel_remove(struct subchannel *sch)
+{
+        struct eadm_private *private = get_eadm_private(sch);
+
+        spin_lock_irq(&list_lock);
+        list_del(&private->head);
+        spin_unlock_irq(&list_lock);
+
+        eadm_quiesce(sch);
+
+        spin_lock_irq(sch->lock);
+        set_eadm_private(sch, NULL);
+        spin_unlock_irq(sch->lock);
+
+        kfree(private);
+
+        return 0;
+}
+
+static void eadm_subchannel_shutdown(struct subchannel *sch)
+{
+        eadm_quiesce(sch);
+}
+
+static int eadm_subchannel_freeze(struct subchannel *sch)
+{
+        return cio_disable_subchannel(sch);
+}
+
+static int eadm_subchannel_restore(struct subchannel *sch)
+{
+        return cio_enable_subchannel(sch, (u32)(unsigned long)sch);
+}
+
+/**
+ * eadm_subchannel_sch_event - process subchannel event
+ * @sch: subchannel
+ * @process: non-zero if function is called in process context
+ *
+ * An unspecified event occurred for this subchannel. Adjust data according
+ * to the current operational state of the subchannel. Return zero when the
+ * event has been handled sufficiently or -EAGAIN when this function should
+ * be called again in process context.
+ */
+static int eadm_subchannel_sch_event(struct subchannel *sch, int process)
+{
+        struct eadm_private *private;
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(sch->lock, flags);
+        if (!device_is_registered(&sch->dev))
+                goto out_unlock;
+
+        if (work_pending(&sch->todo_work))
+                goto out_unlock;
+
+        if (cio_update_schib(sch)) {
+                css_sched_sch_todo(sch, SCH_TODO_UNREG);
+                goto out_unlock;
+        }
+        private = get_eadm_private(sch);
+        if (private->state == EADM_NOT_OPER)
+                private->state = EADM_IDLE;
+
+out_unlock:
+        spin_unlock_irqrestore(sch->lock, flags);
+
+        return ret;
+}
+
+static struct css_device_id eadm_subchannel_ids[] = {
+        { .match_flags = 0x1, .type = SUBCHANNEL_TYPE_ADM, },
+        { /* end of list */ },
+};
+MODULE_DEVICE_TABLE(css, eadm_subchannel_ids);
+
+static struct css_driver eadm_subchannel_driver = {
+        .drv = {
+                .name = "eadm_subchannel",
+                .owner = THIS_MODULE,
+        },
+        .subchannel_type = eadm_subchannel_ids,
+        .irq = eadm_subchannel_irq,
+        .probe = eadm_subchannel_probe,
+        .remove = eadm_subchannel_remove,
+        .shutdown = eadm_subchannel_shutdown,
+        .sch_event = eadm_subchannel_sch_event,
+        .freeze = eadm_subchannel_freeze,
+        .thaw = eadm_subchannel_restore,
+        .restore = eadm_subchannel_restore,
+};
+
+static struct eadm_ops eadm_ops = {
+        .eadm_start = eadm_start_aob,
+        .owner = THIS_MODULE,
+};
+
+static int __init eadm_sch_init(void)
+{
+        int ret;
+
+        if (!css_general_characteristics.eadm)
+                return -ENXIO;
+
+        eadm_debug = debug_register("eadm_log", 16, 1, 16);
+        if (!eadm_debug)
+                return -ENOMEM;
+
+        debug_register_view(eadm_debug, &debug_hex_ascii_view);
+        debug_set_level(eadm_debug, 2);
+
+        isc_register(EADM_SCH_ISC);
+        ret = css_driver_register(&eadm_subchannel_driver);
+        if (ret)
+                goto cleanup;
+
+        register_eadm_ops(&eadm_ops);
+        return ret;
+
+cleanup:
+        isc_unregister(EADM_SCH_ISC);
+        debug_unregister(eadm_debug);
+        return ret;
+}
+
+static void __exit eadm_sch_exit(void)
+{
+        unregister_eadm_ops(&eadm_ops);
+        css_driver_unregister(&eadm_subchannel_driver);
+        isc_unregister(EADM_SCH_ISC);
+        debug_unregister(eadm_debug);
+}
+module_init(eadm_sch_init);
+module_exit(eadm_sch_exit);
diff --git a/drivers/s390/cio/eadm_sch.h b/drivers/s390/cio/eadm_sch.h
new file mode 100644
index 000000000000..2779be093982
--- /dev/null
+++ b/drivers/s390/cio/eadm_sch.h
@@ -0,0 +1,20 @@
+#ifndef EADM_SCH_H
+#define EADM_SCH_H
+
+#include <linux/device.h>
+#include <linux/timer.h>
+#include <linux/list.h>
+#include "orb.h"
+
+struct eadm_private {
+        union orb orb;
+        enum {EADM_IDLE, EADM_BUSY, EADM_NOT_OPER} state;
+        struct timer_list timer;
+        struct list_head head;
+        struct subchannel *sch;
+} __aligned(8);
+
+#define get_eadm_private(n) ((struct eadm_private *)dev_get_drvdata(&n->dev))
+#define set_eadm_private(n, p) (dev_set_drvdata(&n->dev, p))
+
+#endif