[mirror_ubuntu-bionic-kernel.git] / drivers / s390 / cio / eadm_sch.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Driver for s390 eadm subchannels
 *
 * Copyright IBM Corp. 2012
 * Author(s): Sebastian Ott <sebott@linux.vnet.ibm.com>
 */

#include <linux/kernel_stat.h>
#include <linux/completion.h>
#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 (7 * 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)
{
	debug_event(eadm_debug, level, data, length);
}

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(struct timer_list *t)
{
	struct eadm_private *private = from_timer(private, t, timer);
	struct subchannel *sch = private->sch;

	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.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 = this_cpu_ptr(&cio_irb);
	blk_status_t error = BLK_STS_OK;

	EADM_LOG(6, "irq");
	EADM_LOG_HEX(6, irb, sizeof(*irb));

	inc_irq_stat(IRQIO_ADM);

	if ((scsw->stctl & (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND))
	    && scsw->eswf == 1 && irb->esw.eadm.erw.r)
		error = BLK_STS_IOERR;

	if (scsw->fctl & SCSW_FCTL_CLEAR_FUNC)
		error = BLK_STS_TIMEOUT;

	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;

	if (private->completion)
		complete(private->completion);
}

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;
}

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;
}
EXPORT_SYMBOL_GPL(eadm_start_aob);

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);
	timer_setup(&private->timer, eadm_subchannel_timeout, 0);

	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)
{
	struct eadm_private *private = get_eadm_private(sch);
	DECLARE_COMPLETION_ONSTACK(completion);
	int ret;

	spin_lock_irq(sch->lock);
	if (private->state != EADM_BUSY)
		goto disable;

	if (eadm_subchannel_clear(sch))
		goto disable;

	private->completion = &completion;
	spin_unlock_irq(sch->lock);

	wait_for_completion_io(&completion);

	spin_lock_irq(sch->lock);
	private->completion = NULL;

disable:
	eadm_subchannel_set_timeout(sch, 0);
	do {
		ret = cio_disable_subchannel(sch);
	} while (ret == -EBUSY);

	spin_unlock_irq(sch->lock);
}

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;

	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 0;
}

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 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;

	return ret;

cleanup:
	isc_unregister(EADM_SCH_ISC);
	debug_unregister(eadm_debug);
	return ret;
}

static void __exit eadm_sch_exit(void)
{
	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);
Commit	Line	Data
724117b7	1	// SPDX-License-Identifier: GPL-2.0
eadb86ab SO	2	/*
	3	* Driver for s390 eadm subchannels
	4	*
	5	* Copyright IBM Corp. 2012
	6	* Author(s): Sebastian Ott <sebott@linux.vnet.ibm.com>
	7	*/
	8
2e73c2cf	9	#include <linux/kernel_stat.h>
6aa2677a	10	#include <linux/completion.h>
eadb86ab SO	11	#include <linux/workqueue.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/device.h>
	14	#include <linux/module.h>
	15	#include <linux/timer.h>
	16	#include <linux/slab.h>
	17	#include <linux/list.h>
	18
	19	#include <asm/css_chars.h>
	20	#include <asm/debug.h>
	21	#include <asm/isc.h>
	22	#include <asm/cio.h>
	23	#include <asm/scsw.h>
	24	#include <asm/eadm.h>
	25
	26	#include "eadm_sch.h"
	27	#include "ioasm.h"
	28	#include "cio.h"
	29	#include "css.h"
	30	#include "orb.h"
	31
	32	MODULE_DESCRIPTION("driver for s390 eadm subchannels");
	33	MODULE_LICENSE("GPL");
	34
e2578b82	35	#define EADM_TIMEOUT (7 * HZ)
eadb86ab SO	36	static DEFINE_SPINLOCK(list_lock);
	37	static LIST_HEAD(eadm_list);
	38
	39	static debug_info_t *eadm_debug;
	40
	41	#define EADM_LOG(imp, txt) do { \
	42	debug_text_event(eadm_debug, imp, txt); \
	43	} while (0)
	44
	45	static void EADM_LOG_HEX(int level, void *data, int length)
	46	{
94158e54	47	debug_event(eadm_debug, level, data, length);
eadb86ab SO	48	}
	49
	50	static void orb_init(union orb *orb)
	51	{
	52	memset(orb, 0, sizeof(union orb));
	53	orb->eadm.compat1 = 1;
	54	orb->eadm.compat2 = 1;
	55	orb->eadm.fmt = 1;
	56	orb->eadm.x = 1;
	57	}
	58
	59	static int eadm_subchannel_start(struct subchannel sch, struct aob aob)
	60	{
	61	union orb *orb = &get_eadm_private(sch)->orb;
	62	int cc;
	63
	64	orb_init(orb);
	65	orb->eadm.aob = (u32)__pa(aob);
	66	orb->eadm.intparm = (u32)(addr_t)sch;
	67	orb->eadm.key = PAGE_DEFAULT_KEY >> 4;
	68
	69	EADM_LOG(6, "start");
	70	EADM_LOG_HEX(6, &sch->schid, sizeof(sch->schid));
	71
	72	cc = ssch(sch->schid, orb);
	73	switch (cc) {
	74	case 0:
	75	sch->schib.scsw.eadm.actl \|= SCSW_ACTL_START_PEND;
	76	break;
	77	case 1: /* status pending */
	78	case 2: /* busy */
	79	return -EBUSY;
	80	case 3: /* not operational */
	81	return -ENODEV;
	82	}
	83	return 0;
	84	}
	85
	86	static int eadm_subchannel_clear(struct subchannel *sch)
	87	{
	88	int cc;
	89
	90	cc = csch(sch->schid);
	91	if (cc)
	92	return -ENODEV;
	93
	94	sch->schib.scsw.eadm.actl \|= SCSW_ACTL_CLEAR_PEND;
	95	return 0;
	96	}
	97
846d0c6f	98	static void eadm_subchannel_timeout(struct timer_list *t)
eadb86ab	99	{
846d0c6f KC	100	struct eadm_private *private = from_timer(private, t, timer);
846d0c6f KC	101	struct subchannel *sch = private->sch;
eadb86ab SO	102
	103	spin_lock_irq(sch->lock);
	104	EADM_LOG(1, "timeout");
	105	EADM_LOG_HEX(1, &sch->schid, sizeof(sch->schid));
	106	if (eadm_subchannel_clear(sch))
	107	EADM_LOG(0, "clear failed");
	108	spin_unlock_irq(sch->lock);
	109	}
	110
	111	static void eadm_subchannel_set_timeout(struct subchannel *sch, int expires)
	112	{
	113	struct eadm_private *private = get_eadm_private(sch);
	114
	115	if (expires == 0) {
	116	del_timer(&private->timer);
	117	return;
	118	}
	119	if (timer_pending(&private->timer)) {
	120	if (mod_timer(&private->timer, jiffies + expires))
	121	return;
	122	}
eadb86ab SO	123	private->timer.expires = jiffies + expires;
	124	add_timer(&private->timer);
	125	}
	126
	127	static void eadm_subchannel_irq(struct subchannel *sch)
	128	{
	129	struct eadm_private *private = get_eadm_private(sch);
	130	struct eadm_scsw *scsw = &sch->schib.scsw.eadm;
0bf7fcf1	131	struct irb *irb = this_cpu_ptr(&cio_irb);
2a842aca	132	blk_status_t error = BLK_STS_OK;
eadb86ab SO	133
	134	EADM_LOG(6, "irq");
	135	EADM_LOG_HEX(6, irb, sizeof(*irb));
	136
420f42ec	137	inc_irq_stat(IRQIO_ADM);
2e73c2cf	138
eadb86ab SO	139	if ((scsw->stctl & (SCSW_STCTL_ALERT_STATUS \| SCSW_STCTL_STATUS_PEND))
eadb86ab SO	140	&& scsw->eswf == 1 && irb->esw.eadm.erw.r)
2a842aca	141	error = BLK_STS_IOERR;
eadb86ab SO	142
eadb86ab SO	143	if (scsw->fctl & SCSW_FCTL_CLEAR_FUNC)
2a842aca	144	error = BLK_STS_TIMEOUT;
eadb86ab SO	145
	146	eadm_subchannel_set_timeout(sch, 0);
	147
	148	if (private->state != EADM_BUSY) {
	149	EADM_LOG(1, "irq unsol");
	150	EADM_LOG_HEX(1, irb, sizeof(*irb));
	151	private->state = EADM_NOT_OPER;
	152	css_sched_sch_todo(sch, SCH_TODO_EVAL);
	153	return;
	154	}
	155	scm_irq_handler((struct aob *)(unsigned long)scsw->aob, error);
	156	private->state = EADM_IDLE;
6aa2677a SO	157
	158	if (private->completion)
	159	complete(private->completion);
eadb86ab SO	160	}
	161
	162	static struct subchannel *eadm_get_idle_sch(void)
	163	{
	164	struct eadm_private *private;
	165	struct subchannel *sch;
	166	unsigned long flags;
	167
	168	spin_lock_irqsave(&list_lock, flags);
	169	list_for_each_entry(private, &eadm_list, head) {
	170	sch = private->sch;
	171	spin_lock(sch->lock);
	172	if (private->state == EADM_IDLE) {
	173	private->state = EADM_BUSY;
	174	list_move_tail(&private->head, &eadm_list);
	175	spin_unlock(sch->lock);
	176	spin_unlock_irqrestore(&list_lock, flags);
	177
	178	return sch;
	179	}
	180	spin_unlock(sch->lock);
	181	}
	182	spin_unlock_irqrestore(&list_lock, flags);
	183
	184	return NULL;
	185	}
	186
605c3698	187	int eadm_start_aob(struct aob *aob)
eadb86ab SO	188	{
	189	struct eadm_private *private;
	190	struct subchannel *sch;
	191	unsigned long flags;
	192	int ret;
	193
	194	sch = eadm_get_idle_sch();
	195	if (!sch)
	196	return -EBUSY;
	197
	198	spin_lock_irqsave(sch->lock, flags);
	199	eadm_subchannel_set_timeout(sch, EADM_TIMEOUT);
	200	ret = eadm_subchannel_start(sch, aob);
	201	if (!ret)
	202	goto out_unlock;
	203
	204	/* Handle start subchannel failure. */
	205	eadm_subchannel_set_timeout(sch, 0);
	206	private = get_eadm_private(sch);
	207	private->state = EADM_NOT_OPER;
	208	css_sched_sch_todo(sch, SCH_TODO_EVAL);
	209
	210	out_unlock:
	211	spin_unlock_irqrestore(sch->lock, flags);
	212
	213	return ret;
	214	}
605c3698	215	EXPORT_SYMBOL_GPL(eadm_start_aob);
eadb86ab SO	216
	217	static int eadm_subchannel_probe(struct subchannel *sch)
	218	{
	219	struct eadm_private *private;
	220	int ret;
	221
	222	private = kzalloc(sizeof(*private), GFP_KERNEL \| GFP_DMA);
	223	if (!private)
	224	return -ENOMEM;
	225
	226	INIT_LIST_HEAD(&private->head);
846d0c6f	227	timer_setup(&private->timer, eadm_subchannel_timeout, 0);
eadb86ab SO	228
	229	spin_lock_irq(sch->lock);
	230	set_eadm_private(sch, private);
	231	private->state = EADM_IDLE;
	232	private->sch = sch;
	233	sch->isc = EADM_SCH_ISC;
	234	ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch);
	235	if (ret) {
	236	set_eadm_private(sch, NULL);
	237	spin_unlock_irq(sch->lock);
	238	kfree(private);
	239	goto out;
	240	}
	241	spin_unlock_irq(sch->lock);
	242
	243	spin_lock_irq(&list_lock);
	244	list_add(&private->head, &eadm_list);
	245	spin_unlock_irq(&list_lock);
	246
	247	if (dev_get_uevent_suppress(&sch->dev)) {
	248	dev_set_uevent_suppress(&sch->dev, 0);
	249	kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
	250	}
	251	out:
	252	return ret;
	253	}
	254
	255	static void eadm_quiesce(struct subchannel *sch)
	256	{
6aa2677a SO	257	struct eadm_private *private = get_eadm_private(sch);
6aa2677a SO	258	DECLARE_COMPLETION_ONSTACK(completion);
eadb86ab SO	259	int ret;
eadb86ab SO	260
6aa2677a SO	261	spin_lock_irq(sch->lock);
	262	if (private->state != EADM_BUSY)
	263	goto disable;
	264
	265	if (eadm_subchannel_clear(sch))
	266	goto disable;
	267
	268	private->completion = &completion;
	269	spin_unlock_irq(sch->lock);
	270
	271	wait_for_completion_io(&completion);
	272
	273	spin_lock_irq(sch->lock);
	274	private->completion = NULL;
	275
	276	disable:
	277	eadm_subchannel_set_timeout(sch, 0);
eadb86ab	278	do {
eadb86ab	279	ret = cio_disable_subchannel(sch);
eadb86ab	280	} while (ret == -EBUSY);
6aa2677a SO	281
6aa2677a SO	282	spin_unlock_irq(sch->lock);
eadb86ab SO	283	}
	284
	285	static int eadm_subchannel_remove(struct subchannel *sch)
	286	{
	287	struct eadm_private *private = get_eadm_private(sch);
	288
	289	spin_lock_irq(&list_lock);
	290	list_del(&private->head);
	291	spin_unlock_irq(&list_lock);
	292
	293	eadm_quiesce(sch);
	294
	295	spin_lock_irq(sch->lock);
	296	set_eadm_private(sch, NULL);
	297	spin_unlock_irq(sch->lock);
	298
	299	kfree(private);
	300
	301	return 0;
	302	}
	303
	304	static void eadm_subchannel_shutdown(struct subchannel *sch)
	305	{
	306	eadm_quiesce(sch);
	307	}
	308
	309	static int eadm_subchannel_freeze(struct subchannel *sch)
	310	{
	311	return cio_disable_subchannel(sch);
	312	}
	313
	314	static int eadm_subchannel_restore(struct subchannel *sch)
	315	{
	316	return cio_enable_subchannel(sch, (u32)(unsigned long)sch);
	317	}
	318
	319	/**
	320	* eadm_subchannel_sch_event - process subchannel event
	321	* @sch: subchannel
	322	* @process: non-zero if function is called in process context
	323	*
	324	* An unspecified event occurred for this subchannel. Adjust data according
	325	* to the current operational state of the subchannel. Return zero when the
	326	* event has been handled sufficiently or -EAGAIN when this function should
	327	* be called again in process context.
	328	*/
	329	static int eadm_subchannel_sch_event(struct subchannel *sch, int process)
	330	{
	331	struct eadm_private *private;
	332	unsigned long flags;
eadb86ab SO	333
	334	spin_lock_irqsave(sch->lock, flags);
	335	if (!device_is_registered(&sch->dev))
	336	goto out_unlock;
	337
	338	if (work_pending(&sch->todo_work))
	339	goto out_unlock;
	340
	341	if (cio_update_schib(sch)) {
	342	css_sched_sch_todo(sch, SCH_TODO_UNREG);
	343	goto out_unlock;
	344	}
	345	private = get_eadm_private(sch);
	346	if (private->state == EADM_NOT_OPER)
	347	private->state = EADM_IDLE;
	348
	349	out_unlock:
	350	spin_unlock_irqrestore(sch->lock, flags);
	351
b2f4de8b	352	return 0;
eadb86ab SO	353	}
	354
	355	static struct css_device_id eadm_subchannel_ids[] = {
	356	{ .match_flags = 0x1, .type = SUBCHANNEL_TYPE_ADM, },
	357	{ /* end of list */ },
	358	};
	359	MODULE_DEVICE_TABLE(css, eadm_subchannel_ids);
	360
	361	static struct css_driver eadm_subchannel_driver = {
	362	.drv = {
	363	.name = "eadm_subchannel",
	364	.owner = THIS_MODULE,
	365	},
	366	.subchannel_type = eadm_subchannel_ids,
	367	.irq = eadm_subchannel_irq,
	368	.probe = eadm_subchannel_probe,
	369	.remove = eadm_subchannel_remove,
	370	.shutdown = eadm_subchannel_shutdown,
	371	.sch_event = eadm_subchannel_sch_event,
	372	.freeze = eadm_subchannel_freeze,
	373	.thaw = eadm_subchannel_restore,
	374	.restore = eadm_subchannel_restore,
	375	};
	376
eadb86ab SO	377	static int __init eadm_sch_init(void)
	378	{
	379	int ret;
	380
	381	if (!css_general_characteristics.eadm)
	382	return -ENXIO;
	383
	384	eadm_debug = debug_register("eadm_log", 16, 1, 16);
	385	if (!eadm_debug)
	386	return -ENOMEM;
	387
	388	debug_register_view(eadm_debug, &debug_hex_ascii_view);
	389	debug_set_level(eadm_debug, 2);
	390
	391	isc_register(EADM_SCH_ISC);
	392	ret = css_driver_register(&eadm_subchannel_driver);
	393	if (ret)
	394	goto cleanup;
	395
eadb86ab SO	396	return ret;
	397
	398	cleanup:
	399	isc_unregister(EADM_SCH_ISC);
	400	debug_unregister(eadm_debug);
	401	return ret;
	402	}
	403
	404	static void __exit eadm_sch_exit(void)
	405	{
eadb86ab SO	406	css_driver_unregister(&eadm_subchannel_driver);
	407	isc_unregister(EADM_SCH_ISC);
	408	debug_unregister(eadm_debug);
	409	}
	410	module_init(eadm_sch_init);
	411	module_exit(eadm_sch_exit);