[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

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