Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit eadb86ab authored by Sebastian Ott's avatar Sebastian Ott Committed by Martin Schwidefsky
Browse files

s390/cio: add eadm subchannel driver 



This driver allows usage of EADM subchannels. EADM subchannels
act as a communication vehicle for SCM increments.

Signed-off-by: default avatarSebastian Ott <sebott@linux.vnet.ibm.com>
Signed-off-by: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
parent 40ff4cc0

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