[deliverable/linux.git] / drivers / s390 / char / sclp_sdias.c

/*
 * SCLP "store data in absolute storage"
 *
 * Copyright IBM Corp. 2003, 2013
 * Author(s): Michael Holzheu
 */

#define KMSG_COMPONENT "sclp_sdias"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/completion.h>
#include <linux/sched.h>
#include <asm/sclp.h>
#include <asm/debug.h>
#include <asm/ipl.h>

#include "sclp_sdias.h"
#include "sclp.h"
#include "sclp_rw.h"

#define TRACE(x...) debug_sprintf_event(sdias_dbf, 1, x)

#define SDIAS_RETRIES 300
#define SDIAS_SLEEP_TICKS 50

static struct debug_info *sdias_dbf;

static struct sclp_register sclp_sdias_register = {
	.send_mask = EVTYP_SDIAS_MASK,
};

static struct sdias_sccb sccb __attribute__((aligned(4096)));
static struct sdias_evbuf sdias_evbuf;

static DECLARE_COMPLETION(evbuf_accepted);
static DECLARE_COMPLETION(evbuf_done);
static DEFINE_MUTEX(sdias_mutex);

/*
 * Called by SCLP base when read event data has been completed (async mode only)
 */
static void sclp_sdias_receiver_fn(struct evbuf_header *evbuf)
{
	memcpy(&sdias_evbuf, evbuf,
	       min_t(unsigned long, sizeof(sdias_evbuf), evbuf->length));
	complete(&evbuf_done);
	TRACE("sclp_sdias_receiver_fn done\n");
}

/*
 * Called by SCLP base when sdias event has been accepted
 */
static void sdias_callback(struct sclp_req *request, void *data)
{
	complete(&evbuf_accepted);
	TRACE("callback done\n");
}

static int sdias_sclp_send(struct sclp_req *req)
{
	int retries;
	int rc;

	for (retries = SDIAS_RETRIES; retries; retries--) {
		TRACE("add request\n");
		rc = sclp_add_request(req);
		if (rc) {
			/* not initiated, wait some time and retry */
			set_current_state(TASK_INTERRUPTIBLE);
			TRACE("add request failed: rc = %i\n",rc);
			schedule_timeout(SDIAS_SLEEP_TICKS);
			continue;
		}
		/* initiated, wait for completion of service call */
		wait_for_completion(&evbuf_accepted);
		if (req->status == SCLP_REQ_FAILED) {
			TRACE("sclp request failed\n");
			continue;
		}
		/* if not accepted, retry */
		if (!(sccb.evbuf.hdr.flags & 0x80)) {
			TRACE("sclp request failed: flags=%x\n",
			      sccb.evbuf.hdr.flags);
			continue;
		}
		/*
		 * for the sync interface the response is in the initial sccb
		 */
		if (!sclp_sdias_register.receiver_fn) {
			memcpy(&sdias_evbuf, &sccb.evbuf, sizeof(sdias_evbuf));
			TRACE("sync request done\n");
			return 0;
		}
		/* otherwise we wait for completion */
		wait_for_completion(&evbuf_done);
		TRACE("request done\n");
		return 0;
	}
	return -EIO;
}

/*
 * Get number of blocks (4K) available in the HSA
 */
int sclp_sdias_blk_count(void)
{
	struct sclp_req request;
	int rc;

	mutex_lock(&sdias_mutex);

	memset(&sccb, 0, sizeof(sccb));
	memset(&request, 0, sizeof(request));

	sccb.hdr.length = sizeof(sccb);
	sccb.evbuf.hdr.length = sizeof(struct sdias_evbuf);
	sccb.evbuf.hdr.type = EVTYP_SDIAS;
	sccb.evbuf.event_qual = SDIAS_EQ_SIZE;
	sccb.evbuf.data_id = SDIAS_DI_FCP_DUMP;
	sccb.evbuf.event_id = 4712;
	sccb.evbuf.dbs = 1;

	request.sccb = &sccb;
	request.command = SCLP_CMDW_WRITE_EVENT_DATA;
	request.status = SCLP_REQ_FILLED;
	request.callback = sdias_callback;

	rc = sdias_sclp_send(&request);
	if (rc) {
		pr_err("sclp_send failed for get_nr_blocks\n");
		goto out;
	}
	if (sccb.hdr.response_code != 0x0020) {
		TRACE("send failed: %x\n", sccb.hdr.response_code);
		rc = -EIO;
		goto out;
	}

	switch (sdias_evbuf.event_status) {
		case 0:
			rc = sdias_evbuf.blk_cnt;
			break;
		default:
			pr_err("SCLP error: %x\n", sdias_evbuf.event_status);
			rc = -EIO;
			goto out;
	}
	TRACE("%i blocks\n", rc);
out:
	mutex_unlock(&sdias_mutex);
	return rc;
}

/*
 * Copy from HSA to absolute storage (not reentrant):
 *
 * @dest     : Address of buffer where data should be copied
 * @start_blk: Start Block (beginning with 1)
 * @nr_blks  : Number of 4K blocks to copy
 *
 * Return Value: 0 : Requested 'number' of blocks of data copied
 *		 <0: ERROR - negative event status
 */
int sclp_sdias_copy(void *dest, int start_blk, int nr_blks)
{
	struct sclp_req request;
	int rc;

	mutex_lock(&sdias_mutex);

	memset(&sccb, 0, sizeof(sccb));
	memset(&request, 0, sizeof(request));

	sccb.hdr.length = sizeof(sccb);
	sccb.evbuf.hdr.length = sizeof(struct sdias_evbuf);
	sccb.evbuf.hdr.type = EVTYP_SDIAS;
	sccb.evbuf.hdr.flags = 0;
	sccb.evbuf.event_qual = SDIAS_EQ_STORE_DATA;
	sccb.evbuf.data_id = SDIAS_DI_FCP_DUMP;
	sccb.evbuf.event_id = 4712;
#ifdef CONFIG_64BIT
	sccb.evbuf.asa_size = SDIAS_ASA_SIZE_64;
#else
	sccb.evbuf.asa_size = SDIAS_ASA_SIZE_32;
#endif
	sccb.evbuf.event_status = 0;
	sccb.evbuf.blk_cnt = nr_blks;
	sccb.evbuf.asa = (unsigned long)dest;
	sccb.evbuf.fbn = start_blk;
	sccb.evbuf.lbn = 0;
	sccb.evbuf.dbs = 1;

	request.sccb	 = &sccb;
	request.command  = SCLP_CMDW_WRITE_EVENT_DATA;
	request.status	 = SCLP_REQ_FILLED;
	request.callback = sdias_callback;

	rc = sdias_sclp_send(&request);
	if (rc) {
		pr_err("sclp_send failed: %x\n", rc);
		goto out;
	}
	if (sccb.hdr.response_code != 0x0020) {
		TRACE("copy failed: %x\n", sccb.hdr.response_code);
		rc = -EIO;
		goto out;
	}

	switch (sdias_evbuf.event_status) {
	case SDIAS_EVSTATE_ALL_STORED:
		TRACE("all stored\n");
		break;
	case SDIAS_EVSTATE_PART_STORED:
		TRACE("part stored: %i\n", sdias_evbuf.blk_cnt);
		break;
	case SDIAS_EVSTATE_NO_DATA:
		TRACE("no data\n");
		/* fall through */
	default:
		pr_err("Error from SCLP while copying hsa. Event status = %x\n",
		       sdias_evbuf.event_status);
		rc = -EIO;
	}
out:
	mutex_unlock(&sdias_mutex);
	return rc;
}

static int __init sclp_sdias_register_check(void)
{
	int rc;

	rc = sclp_register(&sclp_sdias_register);
	if (rc)
		return rc;
	if (sclp_sdias_blk_count() == 0) {
		sclp_unregister(&sclp_sdias_register);
		return -ENODEV;
	}
	return 0;
}

static int __init sclp_sdias_init_sync(void)
{
	TRACE("Try synchronous mode\n");
	sclp_sdias_register.receive_mask = 0;
	sclp_sdias_register.receiver_fn = NULL;
	return sclp_sdias_register_check();
}

static int __init sclp_sdias_init_async(void)
{
	TRACE("Try asynchronous mode\n");
	sclp_sdias_register.receive_mask = EVTYP_SDIAS_MASK;
	sclp_sdias_register.receiver_fn = sclp_sdias_receiver_fn;
	return sclp_sdias_register_check();
}

int __init sclp_sdias_init(void)
{
	if (ipl_info.type != IPL_TYPE_FCP_DUMP)
		return 0;
	sdias_dbf = debug_register("dump_sdias", 4, 1, 4 * sizeof(long));
	debug_register_view(sdias_dbf, &debug_sprintf_view);
	debug_set_level(sdias_dbf, 6);
	if (sclp_sdias_init_sync() == 0)
		goto out;
	if (sclp_sdias_init_async() == 0)
		goto out;
	TRACE("init failed\n");
	return -ENODEV;
out:
	TRACE("init done\n");
	return 0;
}

void __exit sclp_sdias_exit(void)
{
	debug_unregister(sdias_dbf);
	sclp_unregister(&sclp_sdias_register);
}
Commit	Line	Data
411ed322	1	/*
f8049e3e	2	* SCLP "store data in absolute storage"
411ed322	3	*
f8049e3e	4	* Copyright IBM Corp. 2003, 2013
411ed322 MH	5	* Author(s): Michael Holzheu
	6	*/
	7
b3ff088b MS	8	#define KMSG_COMPONENT "sclp_sdias"
	9	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	10
e3c652b5	11	#include <linux/completion.h>
411ed322 MH	12	#include <linux/sched.h>
	13	#include <asm/sclp.h>
	14	#include <asm/debug.h>
	15	#include <asm/ipl.h>
b3ff088b	16
f8049e3e	17	#include "sclp_sdias.h"
411ed322 MH	18	#include "sclp.h"
	19	#include "sclp_rw.h"
	20
	21	#define TRACE(x...) debug_sprintf_event(sdias_dbf, 1, x)
411ed322 MH	22
	23	#define SDIAS_RETRIES 300
	24	#define SDIAS_SLEEP_TICKS 50
	25
411ed322 MH	26	static struct debug_info *sdias_dbf;
	27
	28	static struct sclp_register sclp_sdias_register = {
6d4740c8	29	.send_mask = EVTYP_SDIAS_MASK,
411ed322 MH	30	};
411ed322 MH	31
411ed322	32	static struct sdias_sccb sccb __attribute__((aligned(4096)));
e3c652b5	33	static struct sdias_evbuf sdias_evbuf;
411ed322	34
e3c652b5 MH	35	static DECLARE_COMPLETION(evbuf_accepted);
e3c652b5 MH	36	static DECLARE_COMPLETION(evbuf_done);
411ed322 MH	37	static DEFINE_MUTEX(sdias_mutex);
411ed322 MH	38
e3c652b5 MH	39	/*
	40	* Called by SCLP base when read event data has been completed (async mode only)
	41	*/
	42	static void sclp_sdias_receiver_fn(struct evbuf_header *evbuf)
	43	{
	44	memcpy(&sdias_evbuf, evbuf,
	45	min_t(unsigned long, sizeof(sdias_evbuf), evbuf->length));
	46	complete(&evbuf_done);
	47	TRACE("sclp_sdias_receiver_fn done\n");
	48	}
	49
	50	/*
	51	* Called by SCLP base when sdias event has been accepted
	52	*/
411ed322 MH	53	static void sdias_callback(struct sclp_req request, void data)
411ed322 MH	54	{
e3c652b5	55	complete(&evbuf_accepted);
411ed322 MH	56	TRACE("callback done\n");
	57	}
	58
	59	static int sdias_sclp_send(struct sclp_req *req)
	60	{
	61	int retries;
	62	int rc;
	63
	64	for (retries = SDIAS_RETRIES; retries; retries--) {
411ed322 MH	65	TRACE("add request\n");
	66	rc = sclp_add_request(req);
	67	if (rc) {
	68	/* not initiated, wait some time and retry */
	69	set_current_state(TASK_INTERRUPTIBLE);
	70	TRACE("add request failed: rc = %i\n",rc);
	71	schedule_timeout(SDIAS_SLEEP_TICKS);
	72	continue;
	73	}
	74	/* initiated, wait for completion of service call */
e3c652b5	75	wait_for_completion(&evbuf_accepted);
411ed322 MH	76	if (req->status == SCLP_REQ_FAILED) {
411ed322 MH	77	TRACE("sclp request failed\n");
411ed322 MH	78	continue;
411ed322 MH	79	}
e3c652b5 MH	80	/* if not accepted, retry */
	81	if (!(sccb.evbuf.hdr.flags & 0x80)) {
	82	TRACE("sclp request failed: flags=%x\n",
	83	sccb.evbuf.hdr.flags);
	84	continue;
	85	}
	86	/*
	87	* for the sync interface the response is in the initial sccb
	88	*/
	89	if (!sclp_sdias_register.receiver_fn) {
	90	memcpy(&sdias_evbuf, &sccb.evbuf, sizeof(sdias_evbuf));
	91	TRACE("sync request done\n");
	92	return 0;
	93	}
	94	/* otherwise we wait for completion */
	95	wait_for_completion(&evbuf_done);
411ed322	96	TRACE("request done\n");
e3c652b5	97	return 0;
411ed322	98	}
e3c652b5	99	return -EIO;
411ed322 MH	100	}
	101
	102	/*
	103	* Get number of blocks (4K) available in the HSA
	104	*/
	105	int sclp_sdias_blk_count(void)
	106	{
	107	struct sclp_req request;
	108	int rc;
	109
	110	mutex_lock(&sdias_mutex);
	111
	112	memset(&sccb, 0, sizeof(sccb));
	113	memset(&request, 0, sizeof(request));
	114
	115	sccb.hdr.length = sizeof(sccb);
	116	sccb.evbuf.hdr.length = sizeof(struct sdias_evbuf);
6d4740c8	117	sccb.evbuf.hdr.type = EVTYP_SDIAS;
f8049e3e MH	118	sccb.evbuf.event_qual = SDIAS_EQ_SIZE;
f8049e3e MH	119	sccb.evbuf.data_id = SDIAS_DI_FCP_DUMP;
411ed322 MH	120	sccb.evbuf.event_id = 4712;
	121	sccb.evbuf.dbs = 1;
	122
	123	request.sccb = &sccb;
	124	request.command = SCLP_CMDW_WRITE_EVENT_DATA;
	125	request.status = SCLP_REQ_FILLED;
	126	request.callback = sdias_callback;
	127
	128	rc = sdias_sclp_send(&request);
	129	if (rc) {
b3ff088b	130	pr_err("sclp_send failed for get_nr_blocks\n");
411ed322 MH	131	goto out;
	132	}
	133	if (sccb.hdr.response_code != 0x0020) {
	134	TRACE("send failed: %x\n", sccb.hdr.response_code);
	135	rc = -EIO;
	136	goto out;
	137	}
	138
e3c652b5	139	switch (sdias_evbuf.event_status) {
411ed322	140	case 0:
e3c652b5	141	rc = sdias_evbuf.blk_cnt;
411ed322 MH	142	break;
411ed322 MH	143	default:
e3c652b5	144	pr_err("SCLP error: %x\n", sdias_evbuf.event_status);
411ed322 MH	145	rc = -EIO;
	146	goto out;
	147	}
	148	TRACE("%i blocks\n", rc);
	149	out:
	150	mutex_unlock(&sdias_mutex);
	151	return rc;
	152	}
	153
	154	/*
	155	* Copy from HSA to absolute storage (not reentrant):
	156	*
	157	* @dest : Address of buffer where data should be copied
	158	* @start_blk: Start Block (beginning with 1)
	159	* @nr_blks : Number of 4K blocks to copy
	160	*
	161	* Return Value: 0 : Requested 'number' of blocks of data copied
	162	* <0: ERROR - negative event status
	163	*/
	164	int sclp_sdias_copy(void *dest, int start_blk, int nr_blks)
	165	{
	166	struct sclp_req request;
	167	int rc;
	168
	169	mutex_lock(&sdias_mutex);
	170
	171	memset(&sccb, 0, sizeof(sccb));
	172	memset(&request, 0, sizeof(request));
	173
	174	sccb.hdr.length = sizeof(sccb);
	175	sccb.evbuf.hdr.length = sizeof(struct sdias_evbuf);
6d4740c8	176	sccb.evbuf.hdr.type = EVTYP_SDIAS;
411ed322	177	sccb.evbuf.hdr.flags = 0;
f8049e3e MH	178	sccb.evbuf.event_qual = SDIAS_EQ_STORE_DATA;
f8049e3e MH	179	sccb.evbuf.data_id = SDIAS_DI_FCP_DUMP;
411ed322	180	sccb.evbuf.event_id = 4712;
f4815ac6	181	#ifdef CONFIG_64BIT
f8049e3e	182	sccb.evbuf.asa_size = SDIAS_ASA_SIZE_64;
411ed322	183	#else
f8049e3e	184	sccb.evbuf.asa_size = SDIAS_ASA_SIZE_32;
411ed322 MH	185	#endif
	186	sccb.evbuf.event_status = 0;
	187	sccb.evbuf.blk_cnt = nr_blks;
	188	sccb.evbuf.asa = (unsigned long)dest;
	189	sccb.evbuf.fbn = start_blk;
	190	sccb.evbuf.lbn = 0;
	191	sccb.evbuf.dbs = 1;
	192
	193	request.sccb = &sccb;
	194	request.command = SCLP_CMDW_WRITE_EVENT_DATA;
	195	request.status = SCLP_REQ_FILLED;
	196	request.callback = sdias_callback;
	197
	198	rc = sdias_sclp_send(&request);
	199	if (rc) {
b3ff088b	200	pr_err("sclp_send failed: %x\n", rc);
411ed322 MH	201	goto out;
	202	}
	203	if (sccb.hdr.response_code != 0x0020) {
	204	TRACE("copy failed: %x\n", sccb.hdr.response_code);
	205	rc = -EIO;
	206	goto out;
	207	}
	208
e3c652b5	209	switch (sdias_evbuf.event_status) {
f8049e3e MH	210	case SDIAS_EVSTATE_ALL_STORED:
	211	TRACE("all stored\n");
	212	break;
	213	case SDIAS_EVSTATE_PART_STORED:
	214	TRACE("part stored: %i\n", sdias_evbuf.blk_cnt);
	215	break;
	216	case SDIAS_EVSTATE_NO_DATA:
	217	TRACE("no data\n");
	218	/* fall through */
	219	default:
	220	pr_err("Error from SCLP while copying hsa. Event status = %x\n",
	221	sdias_evbuf.event_status);
	222	rc = -EIO;
411ed322 MH	223	}
	224	out:
	225	mutex_unlock(&sdias_mutex);
	226	return rc;
	227	}
	228
e3c652b5	229	static int __init sclp_sdias_register_check(void)
411ed322 MH	230	{
	231	int rc;
	232
e3c652b5 MH	233	rc = sclp_register(&sclp_sdias_register);
	234	if (rc)
	235	return rc;
	236	if (sclp_sdias_blk_count() == 0) {
	237	sclp_unregister(&sclp_sdias_register);
	238	return -ENODEV;
	239	}
	240	return 0;
	241	}
	242
	243	static int __init sclp_sdias_init_sync(void)
	244	{
	245	TRACE("Try synchronous mode\n");
	246	sclp_sdias_register.receive_mask = 0;
	247	sclp_sdias_register.receiver_fn = NULL;
	248	return sclp_sdias_register_check();
	249	}
	250
	251	static int __init sclp_sdias_init_async(void)
	252	{
	253	TRACE("Try asynchronous mode\n");
	254	sclp_sdias_register.receive_mask = EVTYP_SDIAS_MASK;
	255	sclp_sdias_register.receiver_fn = sclp_sdias_receiver_fn;
	256	return sclp_sdias_register_check();
	257	}
	258
	259	int __init sclp_sdias_init(void)
	260	{
411ed322 MH	261	if (ipl_info.type != IPL_TYPE_FCP_DUMP)
	262	return 0;
	263	sdias_dbf = debug_register("dump_sdias", 4, 1, 4 * sizeof(long));
	264	debug_register_view(sdias_dbf, &debug_sprintf_view);
	265	debug_set_level(sdias_dbf, 6);
e3c652b5 MH	266	if (sclp_sdias_init_sync() == 0)
	267	goto out;
	268	if (sclp_sdias_init_async() == 0)
	269	goto out;
	270	TRACE("init failed\n");
	271	return -ENODEV;
	272	out:
411ed322 MH	273	TRACE("init done\n");
	274	return 0;
	275	}
	276
763968e2	277	void __exit sclp_sdias_exit(void)
411ed322 MH	278	{
	279	debug_unregister(sdias_dbf);
	280	sclp_unregister(&sclp_sdias_register);
	281	}