s390/cio: add eadm subchannel driver (eadb86ab) · Commits · 戴 / test

arch/s390/Kconfig

+11 −0

Original line number	Diff line number	Diff line
		@@ -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"

arch/s390/include/asm/isc.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -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 */

drivers/s390/cio/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -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

drivers/s390/cio/eadm_sch.c

0 → 100644

+398 −0

Original line number	Diff line number	Diff line
		/*
		* 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);

drivers/s390/cio/eadm_sch.h

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		#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

Admin message