[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / s390 / cio / device_pgid.c

/*
 *  CCW device PGID and path verification I/O handling.
 *
 *    Copyright IBM Corp. 2002, 2009
 *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
 *		 Martin Schwidefsky <schwidefsky@de.ibm.com>
 *		 Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
 */

#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/bitops.h>
#include <asm/ccwdev.h>
#include <asm/cio.h>

#include "cio.h"
#include "cio_debug.h"
#include "device.h"
#include "io_sch.h"

#define PGID_RETRIES	256
#define PGID_TIMEOUT	(10 * HZ)

static void verify_start(struct ccw_device *cdev);

/*
 * Process path verification data and report result.
 */
static void verify_done(struct ccw_device *cdev, int rc)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_dev_id *id = &cdev->private->dev_id;
	int mpath = cdev->private->flags.mpath;
	int pgroup = cdev->private->flags.pgroup;

	if (rc)
		goto out;
	/* Ensure consistent multipathing state at device and channel. */
	if (sch->config.mp != mpath) {
		sch->config.mp = mpath;
		rc = cio_commit_config(sch);
	}
out:
	CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "
			 "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,
			 sch->vpm);
	ccw_device_verify_done(cdev, rc);
}

/*
 * Create channel program to perform a NOOP.
 */
static void nop_build_cp(struct ccw_device *cdev)
{
	struct ccw_request *req = &cdev->private->req;
	struct ccw1 *cp = cdev->private->iccws;

	cp->cmd_code	= CCW_CMD_NOOP;
	cp->cda		= 0;
	cp->count	= 0;
	cp->flags	= CCW_FLAG_SLI;
	req->cp		= cp;
}

/*
 * Perform NOOP on a single path.
 */
static void nop_do(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;

	req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm &
			      ~cdev->private->path_noirq_mask);
	if (!req->lpm)
		goto out_nopath;
	nop_build_cp(cdev);
	ccw_request_start(cdev);
	return;

out_nopath:
	verify_done(cdev, sch->vpm ? 0 : -EACCES);
}

/*
 * Adjust NOOP I/O status.
 */
static enum io_status nop_filter(struct ccw_device *cdev, void *data,
				 struct irb *irb, enum io_status status)
{
	/* Only subchannel status might indicate a path error. */
	if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)
		return IO_DONE;
	return status;
}

/*
 * Process NOOP request result for a single path.
 */
static void nop_callback(struct ccw_device *cdev, void *data, int rc)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;

	switch (rc) {
	case 0:
		sch->vpm |= req->lpm;
		break;
	case -ETIME:
		cdev->private->path_noirq_mask |= req->lpm;
		break;
	case -EACCES:
		cdev->private->path_notoper_mask |= req->lpm;
		break;
	default:
		goto err;
	}
	/* Continue on the next path. */
	req->lpm >>= 1;
	nop_do(cdev);
	return;

err:
	verify_done(cdev, rc);
}

/*
 * Create channel program to perform SET PGID on a single path.
 */
static void spid_build_cp(struct ccw_device *cdev, u8 fn)
{
	struct ccw_request *req = &cdev->private->req;
	struct ccw1 *cp = cdev->private->iccws;
	int i = 8 - ffs(req->lpm);
	struct pgid *pgid = &cdev->private->pgid[i];

	pgid->inf.fc	= fn;
	cp->cmd_code	= CCW_CMD_SET_PGID;
	cp->cda		= (u32) (addr_t) pgid;
	cp->count	= sizeof(*pgid);
	cp->flags	= CCW_FLAG_SLI;
	req->cp		= cp;
}

static void pgid_wipeout_callback(struct ccw_device *cdev, void *data, int rc)
{
	if (rc) {
		/* We don't know the path groups' state. Abort. */
		verify_done(cdev, rc);
		return;
	}
	/*
	 * Path groups have been reset. Restart path verification but
	 * leave paths in path_noirq_mask out.
	 */
	cdev->private->flags.pgid_unknown = 0;
	verify_start(cdev);
}

/*
 * Reset pathgroups and restart path verification, leave unusable paths out.
 */
static void pgid_wipeout_start(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_dev_id *id = &cdev->private->dev_id;
	struct ccw_request *req = &cdev->private->req;
	u8 fn;

	CIO_MSG_EVENT(2, "wipe: device 0.%x.%04x: pvm=%02x nim=%02x\n",
		      id->ssid, id->devno, cdev->private->pgid_valid_mask,
		      cdev->private->path_noirq_mask);

	/* Initialize request data. */
	memset(req, 0, sizeof(*req));
	req->timeout	= PGID_TIMEOUT;
	req->maxretries	= PGID_RETRIES;
	req->lpm	= sch->schib.pmcw.pam;
	req->callback	= pgid_wipeout_callback;
	fn = SPID_FUNC_DISBAND;
	if (cdev->private->flags.mpath)
		fn |= SPID_FUNC_MULTI_PATH;
	spid_build_cp(cdev, fn);
	ccw_request_start(cdev);
}

/*
 * Perform establish/resign SET PGID on a single path.
 */
static void spid_do(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;
	u8 fn;

	/* Use next available path that is not already in correct state. */
	req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask);
	if (!req->lpm)
		goto out_nopath;
	/* Channel program setup. */
	if (req->lpm & sch->opm)
		fn = SPID_FUNC_ESTABLISH;
	else
		fn = SPID_FUNC_RESIGN;
	if (cdev->private->flags.mpath)
		fn |= SPID_FUNC_MULTI_PATH;
	spid_build_cp(cdev, fn);
	ccw_request_start(cdev);
	return;

out_nopath:
	if (cdev->private->flags.pgid_unknown) {
		/* At least one SPID could be partially done. */
		pgid_wipeout_start(cdev);
		return;
	}
	verify_done(cdev, sch->vpm ? 0 : -EACCES);
}

/*
 * Process SET PGID request result for a single path.
 */
static void spid_callback(struct ccw_device *cdev, void *data, int rc)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;

	switch (rc) {
	case 0:
		sch->vpm |= req->lpm & sch->opm;
		break;
	case -ETIME:
		cdev->private->flags.pgid_unknown = 1;
		cdev->private->path_noirq_mask |= req->lpm;
		break;
	case -EACCES:
		cdev->private->path_notoper_mask |= req->lpm;
		break;
	case -EOPNOTSUPP:
		if (cdev->private->flags.mpath) {
			/* Try without multipathing. */
			cdev->private->flags.mpath = 0;
			goto out_restart;
		}
		/* Try without pathgrouping. */
		cdev->private->flags.pgroup = 0;
		goto out_restart;
	default:
		goto err;
	}
	req->lpm >>= 1;
	spid_do(cdev);
	return;

out_restart:
	verify_start(cdev);
	return;
err:
	verify_done(cdev, rc);
}

static void spid_start(struct ccw_device *cdev)
{
	struct ccw_request *req = &cdev->private->req;

	/* Initialize request data. */
	memset(req, 0, sizeof(*req));
	req->timeout	= PGID_TIMEOUT;
	req->maxretries	= PGID_RETRIES;
	req->lpm	= 0x80;
	req->singlepath	= 1;
	req->callback	= spid_callback;
	spid_do(cdev);
}

static int pgid_is_reset(struct pgid *p)
{
	char *c;

	for (c = (char *)p + 1; c < (char *)(p + 1); c++) {
		if (*c != 0)
			return 0;
	}
	return 1;
}

static int pgid_cmp(struct pgid *p1, struct pgid *p2)
{
	return memcmp((char *) p1 + 1, (char *) p2 + 1,
		      sizeof(struct pgid) - 1);
}

/*
 * Determine pathgroup state from PGID data.
 */
static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
			 int *mismatch, u8 *reserved, u8 *reset)
{
	struct pgid *pgid = &cdev->private->pgid[0];
	struct pgid *first = NULL;
	int lpm;
	int i;

	*mismatch = 0;
	*reserved = 0;
	*reset = 0;
	for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {
		if ((cdev->private->pgid_valid_mask & lpm) == 0)
			continue;
		if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)
			*reserved |= lpm;
		if (pgid_is_reset(pgid)) {
			*reset |= lpm;
			continue;
		}
		if (!first) {
			first = pgid;
			continue;
		}
		if (pgid_cmp(pgid, first) != 0)
			*mismatch = 1;
	}
	if (!first)
		first = &channel_subsystems[0]->global_pgid;
	*p = first;
}

static u8 pgid_to_donepm(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct pgid *pgid;
	int i;
	int lpm;
	u8 donepm = 0;

	/* Set bits for paths which are already in the target state. */
	for (i = 0; i < 8; i++) {
		lpm = 0x80 >> i;
		if ((cdev->private->pgid_valid_mask & lpm) == 0)
			continue;
		pgid = &cdev->private->pgid[i];
		if (sch->opm & lpm) {
			if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED)
				continue;
		} else {
			if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED)
				continue;
		}
		if (cdev->private->flags.mpath) {
			if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH)
				continue;
		} else {
			if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH)
				continue;
		}
		donepm |= lpm;
	}

	return donepm;
}

static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid)
{
	int i;

	for (i = 0; i < 8; i++)
		memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid));
}

/*
 * Process SENSE PGID data and report result.
 */
static void snid_done(struct ccw_device *cdev, int rc)
{
	struct ccw_dev_id *id = &cdev->private->dev_id;
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct pgid *pgid;
	int mismatch = 0;
	u8 reserved = 0;
	u8 reset = 0;
	u8 donepm;

	if (rc)
		goto out;
	pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);
	if (reserved == cdev->private->pgid_valid_mask)
		rc = -EUSERS;
	else if (mismatch)
		rc = -EOPNOTSUPP;
	else {
		donepm = pgid_to_donepm(cdev);
		sch->vpm = donepm & sch->opm;
		cdev->private->pgid_reset_mask |= reset;
		cdev->private->pgid_todo_mask &=
			~(donepm | cdev->private->path_noirq_mask);
		pgid_fill(cdev, pgid);
	}
out:
	CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x "
		      "todo=%02x mism=%d rsvd=%02x reset=%02x\n", id->ssid,
		      id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,
		      cdev->private->pgid_todo_mask, mismatch, reserved, reset);
	switch (rc) {
	case 0:
		if (cdev->private->flags.pgid_unknown) {
			pgid_wipeout_start(cdev);
			return;
		}
		/* Anything left to do? */
		if (cdev->private->pgid_todo_mask == 0) {
			verify_done(cdev, sch->vpm == 0 ? -EACCES : 0);
			return;
		}
		/* Perform path-grouping. */
		spid_start(cdev);
		break;
	case -EOPNOTSUPP:
		/* Path-grouping not supported. */
		cdev->private->flags.pgroup = 0;
		cdev->private->flags.mpath = 0;
		verify_start(cdev);
		break;
	default:
		verify_done(cdev, rc);
	}
}

/*
 * Create channel program to perform a SENSE PGID on a single path.
 */
static void snid_build_cp(struct ccw_device *cdev)
{
	struct ccw_request *req = &cdev->private->req;
	struct ccw1 *cp = cdev->private->iccws;
	int i = 8 - ffs(req->lpm);

	/* Channel program setup. */
	cp->cmd_code	= CCW_CMD_SENSE_PGID;
	cp->cda		= (u32) (addr_t) &cdev->private->pgid[i];
	cp->count	= sizeof(struct pgid);
	cp->flags	= CCW_FLAG_SLI;
	req->cp		= cp;
}

/*
 * Perform SENSE PGID on a single path.
 */
static void snid_do(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;
	int ret;

	req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam &
			      ~cdev->private->path_noirq_mask);
	if (!req->lpm)
		goto out_nopath;
	snid_build_cp(cdev);
	ccw_request_start(cdev);
	return;

out_nopath:
	if (cdev->private->pgid_valid_mask)
		ret = 0;
	else if (cdev->private->path_noirq_mask)
		ret = -ETIME;
	else
		ret = -EACCES;
	snid_done(cdev, ret);
}

/*
 * Process SENSE PGID request result for single path.
 */
static void snid_callback(struct ccw_device *cdev, void *data, int rc)
{
	struct ccw_request *req = &cdev->private->req;

	switch (rc) {
	case 0:
		cdev->private->pgid_valid_mask |= req->lpm;
		break;
	case -ETIME:
		cdev->private->flags.pgid_unknown = 1;
		cdev->private->path_noirq_mask |= req->lpm;
		break;
	case -EACCES:
		cdev->private->path_notoper_mask |= req->lpm;
		break;
	default:
		goto err;
	}
	/* Continue on the next path. */
	req->lpm >>= 1;
	snid_do(cdev);
	return;

err:
	snid_done(cdev, rc);
}

/*
 * Perform path verification.
 */
static void verify_start(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;
	struct ccw_dev_id *devid = &cdev->private->dev_id;

	sch->vpm = 0;
	sch->lpm = sch->schib.pmcw.pam;

	/* Initialize PGID data. */
	memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid));
	cdev->private->pgid_valid_mask = 0;
	cdev->private->pgid_todo_mask = sch->schib.pmcw.pam;
	cdev->private->path_notoper_mask = 0;

	/* Initialize request data. */
	memset(req, 0, sizeof(*req));
	req->timeout	= PGID_TIMEOUT;
	req->maxretries	= PGID_RETRIES;
	req->lpm	= 0x80;
	req->singlepath	= 1;
	if (cdev->private->flags.pgroup) {
		CIO_TRACE_EVENT(4, "snid");
		CIO_HEX_EVENT(4, devid, sizeof(*devid));
		req->callback	= snid_callback;
		snid_do(cdev);
	} else {
		CIO_TRACE_EVENT(4, "nop");
		CIO_HEX_EVENT(4, devid, sizeof(*devid));
		req->filter	= nop_filter;
		req->callback	= nop_callback;
		nop_do(cdev);
	}
}

/**
 * ccw_device_verify_start - perform path verification
 * @cdev: ccw device
 *
 * Perform an I/O on each available channel path to @cdev to determine which
 * paths are operational. The resulting path mask is stored in sch->vpm.
 * If device options specify pathgrouping, establish a pathgroup for the
 * operational paths. When finished, call ccw_device_verify_done with a
 * return code specifying the result.
 */
void ccw_device_verify_start(struct ccw_device *cdev)
{
	CIO_TRACE_EVENT(4, "vrfy");
	CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
	/*
	 * Initialize pathgroup and multipath state with target values.
	 * They may change in the course of path verification.
	 */
	cdev->private->flags.pgroup = cdev->private->options.pgroup;
	cdev->private->flags.mpath = cdev->private->options.mpath;
	cdev->private->flags.doverify = 0;
	cdev->private->path_noirq_mask = 0;
	verify_start(cdev);
}

/*
 * Process disband SET PGID request result.
 */
static void disband_callback(struct ccw_device *cdev, void *data, int rc)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_dev_id *id = &cdev->private->dev_id;

	if (rc)
		goto out;
	/* Ensure consistent multipathing state at device and channel. */
	cdev->private->flags.mpath = 0;
	if (sch->config.mp) {
		sch->config.mp = 0;
		rc = cio_commit_config(sch);
	}
out:
	CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,
		      rc);
	ccw_device_disband_done(cdev, rc);
}

/**
 * ccw_device_disband_start - disband pathgroup
 * @cdev: ccw device
 *
 * Execute a SET PGID channel program on @cdev to disband a previously
 * established pathgroup. When finished, call ccw_device_disband_done with
 * a return code specifying the result.
 */
void ccw_device_disband_start(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;
	u8 fn;

	CIO_TRACE_EVENT(4, "disb");
	CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
	/* Request setup. */
	memset(req, 0, sizeof(*req));
	req->timeout	= PGID_TIMEOUT;
	req->maxretries	= PGID_RETRIES;
	req->lpm	= sch->schib.pmcw.pam & sch->opm;
	req->singlepath	= 1;
	req->callback	= disband_callback;
	fn = SPID_FUNC_DISBAND;
	if (cdev->private->flags.mpath)
		fn |= SPID_FUNC_MULTI_PATH;
	spid_build_cp(cdev, fn);
	ccw_request_start(cdev);
}

static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2)
{
	struct ccw_request *req = &cdev->private->req;
	struct ccw1 *cp = cdev->private->iccws;

	cp[0].cmd_code = CCW_CMD_STLCK;
	cp[0].cda = (u32) (addr_t) buf1;
	cp[0].count = 32;
	cp[0].flags = CCW_FLAG_CC;
	cp[1].cmd_code = CCW_CMD_RELEASE;
	cp[1].cda = (u32) (addr_t) buf2;
	cp[1].count = 32;
	cp[1].flags = 0;
	req->cp = cp;
}

static void stlck_callback(struct ccw_device *cdev, void *data, int rc)
{
	ccw_device_stlck_done(cdev, data, rc);
}

/**
 * ccw_device_stlck_start - perform unconditional release
 * @cdev: ccw device
 * @data: data pointer to be passed to ccw_device_stlck_done
 * @buf1: data pointer used in channel program
 * @buf2: data pointer used in channel program
 *
 * Execute a channel program on @cdev to release an existing PGID reservation.
 * When finished, call ccw_device_stlck_done with a return code specifying the
 * result.
 */
void ccw_device_stlck_start(struct ccw_device *cdev, void *data, void *buf1,
			    void *buf2)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;

	CIO_TRACE_EVENT(4, "stlck");
	CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
	/* Request setup. */
	memset(req, 0, sizeof(*req));
	req->timeout	= PGID_TIMEOUT;
	req->maxretries	= PGID_RETRIES;
	req->lpm	= sch->schib.pmcw.pam & sch->opm;
	req->data	= data;
	req->callback	= stlck_callback;
	stlck_build_cp(cdev, buf1, buf2);
	ccw_request_start(cdev);
}
Commit	Line	Data
1da177e4	1	/*
9679baaf	2	* CCW device PGID and path verification I/O handling.
1da177e4	3	*
a53c8fab	4	* Copyright IBM Corp. 2002, 2009
9679baaf PO	5	* Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
	6	* Martin Schwidefsky <schwidefsky@de.ibm.com>
	7	* Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
1da177e4 LT	8	*/
1da177e4 LT	9
9679baaf PO	10	#include <linux/kernel.h>
	11	#include <linux/string.h>
	12	#include <linux/types.h>
	13	#include <linux/errno.h>
	14	#include <linux/bitops.h>
1da177e4 LT	15	#include <asm/ccwdev.h>
1da177e4 LT	16	#include <asm/cio.h>
1da177e4 LT	17
	18	#include "cio.h"
	19	#include "cio_debug.h"
1da177e4	20	#include "device.h"
cd6b4f27	21	#include "io_sch.h"
1da177e4	22
de1b0438	23	#define PGID_RETRIES 256
9679baaf PO	24	#define PGID_TIMEOUT (10 * HZ)
9679baaf PO	25
88e7616e SO	26	static void verify_start(struct ccw_device *cdev);
88e7616e SO	27
7b7db1b5	28	/*
9679baaf	29	* Process path verification data and report result.
7b7db1b5	30	*/
9679baaf	31	static void verify_done(struct ccw_device *cdev, int rc)
7b7db1b5	32	{
9679baaf PO	33	struct subchannel *sch = to_subchannel(cdev->dev.parent);
9679baaf PO	34	struct ccw_dev_id *id = &cdev->private->dev_id;
454e1fa1 PO	35	int mpath = cdev->private->flags.mpath;
454e1fa1 PO	36	int pgroup = cdev->private->flags.pgroup;
9679baaf PO	37
	38	if (rc)
	39	goto out;
	40	/* Ensure consistent multipathing state at device and channel. */
	41	if (sch->config.mp != mpath) {
	42	sch->config.mp = mpath;
	43	rc = cio_commit_config(sch);
	44	}
	45	out:
	46	CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "
	47	"vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,
	48	sch->vpm);
	49	ccw_device_verify_done(cdev, rc);
7b7db1b5 SB	50	}
7b7db1b5 SB	51
1da177e4	52	/*
9679baaf	53	* Create channel program to perform a NOOP.
1da177e4	54	*/
9679baaf	55	static void nop_build_cp(struct ccw_device *cdev)
1da177e4	56	{
9679baaf PO	57	struct ccw_request *req = &cdev->private->req;
	58	struct ccw1 *cp = cdev->private->iccws;
	59
	60	cp->cmd_code = CCW_CMD_NOOP;
	61	cp->cda = 0;
	62	cp->count = 0;
	63	cp->flags = CCW_FLAG_SLI;
	64	req->cp = cp;
1da177e4 LT	65	}
1da177e4 LT	66
9679baaf PO	67	/*
	68	* Perform NOOP on a single path.
	69	*/
	70	static void nop_do(struct ccw_device *cdev)
1da177e4	71	{
9679baaf PO	72	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	73	struct ccw_request *req = &cdev->private->req;
	74
e6a0b7c9 SO	75	req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm &
e6a0b7c9 SO	76	~cdev->private->path_noirq_mask);
9679baaf PO	77	if (!req->lpm)
	78	goto out_nopath;
	79	nop_build_cp(cdev);
	80	ccw_request_start(cdev);
	81	return;
	82
	83	out_nopath:
	84	verify_done(cdev, sch->vpm ? 0 : -EACCES);
1da177e4 LT	85	}
	86
	87	/*
9679baaf	88	* Adjust NOOP I/O status.
1da177e4	89	*/
9679baaf PO	90	static enum io_status nop_filter(struct ccw_device cdev, void data,
9679baaf PO	91	struct irb *irb, enum io_status status)
1da177e4	92	{
9679baaf PO	93	/* Only subchannel status might indicate a path error. */
	94	if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)
	95	return IO_DONE;
	96	return status;
1da177e4 LT	97	}
	98
	99	/*
9679baaf	100	* Process NOOP request result for a single path.
1da177e4	101	*/
9679baaf	102	static void nop_callback(struct ccw_device cdev, void data, int rc)
1da177e4	103	{
9679baaf PO	104	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	105	struct ccw_request *req = &cdev->private->req;
	106
69f5576f SO	107	switch (rc) {
69f5576f SO	108	case 0:
9679baaf	109	sch->vpm \|= req->lpm;
69f5576f SO	110	break;
	111	case -ETIME:
	112	cdev->private->path_noirq_mask \|= req->lpm;
	113	break;
	114	case -EACCES:
	115	cdev->private->path_notoper_mask \|= req->lpm;
	116	break;
	117	default:
9679baaf	118	goto err;
69f5576f SO	119	}
69f5576f SO	120	/* Continue on the next path. */
9679baaf PO	121	req->lpm >>= 1;
	122	nop_do(cdev);
	123	return;
	124
	125	err:
	126	verify_done(cdev, rc);
1da177e4 LT	127	}
	128
	129	/*
9679baaf	130	* Create channel program to perform SET PGID on a single path.
1da177e4	131	*/
9679baaf	132	static void spid_build_cp(struct ccw_device *cdev, u8 fn)
1da177e4	133	{
9679baaf PO	134	struct ccw_request *req = &cdev->private->req;
	135	struct ccw1 *cp = cdev->private->iccws;
	136	int i = 8 - ffs(req->lpm);
	137	struct pgid *pgid = &cdev->private->pgid[i];
	138
	139	pgid->inf.fc = fn;
	140	cp->cmd_code = CCW_CMD_SET_PGID;
	141	cp->cda = (u32) (addr_t) pgid;
	142	cp->count = sizeof(*pgid);
	143	cp->flags = CCW_FLAG_SLI;
	144	req->cp = cp;
1da177e4 LT	145	}
1da177e4 LT	146
88e7616e SO	147	static void pgid_wipeout_callback(struct ccw_device cdev, void data, int rc)
	148	{
	149	if (rc) {
	150	/* We don't know the path groups' state. Abort. */
	151	verify_done(cdev, rc);
	152	return;
	153	}
	154	/*
	155	* Path groups have been reset. Restart path verification but
	156	* leave paths in path_noirq_mask out.
	157	*/
	158	cdev->private->flags.pgid_unknown = 0;
	159	verify_start(cdev);
	160	}
	161
	162	/*
	163	* Reset pathgroups and restart path verification, leave unusable paths out.
	164	*/
	165	static void pgid_wipeout_start(struct ccw_device *cdev)
	166	{
	167	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	168	struct ccw_dev_id *id = &cdev->private->dev_id;
	169	struct ccw_request *req = &cdev->private->req;
	170	u8 fn;
	171
	172	CIO_MSG_EVENT(2, "wipe: device 0.%x.%04x: pvm=%02x nim=%02x\n",
	173	id->ssid, id->devno, cdev->private->pgid_valid_mask,
	174	cdev->private->path_noirq_mask);
	175
	176	/* Initialize request data. */
	177	memset(req, 0, sizeof(*req));
	178	req->timeout = PGID_TIMEOUT;
	179	req->maxretries = PGID_RETRIES;
	180	req->lpm = sch->schib.pmcw.pam;
	181	req->callback = pgid_wipeout_callback;
	182	fn = SPID_FUNC_DISBAND;
	183	if (cdev->private->flags.mpath)
	184	fn \|= SPID_FUNC_MULTI_PATH;
	185	spid_build_cp(cdev, fn);
	186	ccw_request_start(cdev);
	187	}
	188
7e560814	189	/*
9679baaf	190	* Perform establish/resign SET PGID on a single path.
7e560814	191	*/
9679baaf	192	static void spid_do(struct ccw_device *cdev)
7e560814	193	{
9679baaf PO	194	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	195	struct ccw_request *req = &cdev->private->req;
	196	u8 fn;
	197
52ef0608	198	/* Use next available path that is not already in correct state. */
d302e1a5	199	req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask);
9679baaf PO	200	if (!req->lpm)
	201	goto out_nopath;
	202	/* Channel program setup. */
	203	if (req->lpm & sch->opm)
	204	fn = SPID_FUNC_ESTABLISH;
	205	else
	206	fn = SPID_FUNC_RESIGN;
454e1fa1	207	if (cdev->private->flags.mpath)
9679baaf PO	208	fn \|= SPID_FUNC_MULTI_PATH;
	209	spid_build_cp(cdev, fn);
	210	ccw_request_start(cdev);
	211	return;
	212
	213	out_nopath:
88e7616e SO	214	if (cdev->private->flags.pgid_unknown) {
	215	/* At least one SPID could be partially done. */
	216	pgid_wipeout_start(cdev);
	217	return;
	218	}
9679baaf	219	verify_done(cdev, sch->vpm ? 0 : -EACCES);
7e560814 CH	220	}
7e560814 CH	221
1da177e4	222	/*
9679baaf	223	* Process SET PGID request result for a single path.
1da177e4	224	*/
9679baaf	225	static void spid_callback(struct ccw_device cdev, void data, int rc)
1da177e4	226	{
9679baaf PO	227	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	228	struct ccw_request *req = &cdev->private->req;
	229
	230	switch (rc) {
	231	case 0:
	232	sch->vpm \|= req->lpm & sch->opm;
	233	break;
69f5576f SO	234	case -ETIME:
	235	cdev->private->flags.pgid_unknown = 1;
	236	cdev->private->path_noirq_mask \|= req->lpm;
	237	break;
9679baaf	238	case -EACCES:
69f5576f	239	cdev->private->path_notoper_mask \|= req->lpm;
9679baaf PO	240	break;
9679baaf PO	241	case -EOPNOTSUPP:
454e1fa1	242	if (cdev->private->flags.mpath) {
9679baaf	243	/* Try without multipathing. */
454e1fa1	244	cdev->private->flags.mpath = 0;
9679baaf	245	goto out_restart;
d23861ff	246	}
9679baaf	247	/* Try without pathgrouping. */
454e1fa1	248	cdev->private->flags.pgroup = 0;
9679baaf PO	249	goto out_restart;
	250	default:
	251	goto err;
1da177e4	252	}
9679baaf PO	253	req->lpm >>= 1;
	254	spid_do(cdev);
	255	return;
	256
	257	out_restart:
	258	verify_start(cdev);
	259	return;
	260	err:
	261	verify_done(cdev, rc);
	262	}
	263
52ef0608 PO	264	static void spid_start(struct ccw_device *cdev)
	265	{
	266	struct ccw_request *req = &cdev->private->req;
	267
	268	/* Initialize request data. */
	269	memset(req, 0, sizeof(*req));
	270	req->timeout = PGID_TIMEOUT;
	271	req->maxretries = PGID_RETRIES;
	272	req->lpm = 0x80;
982bdf81	273	req->singlepath = 1;
52ef0608 PO	274	req->callback = spid_callback;
	275	spid_do(cdev);
	276	}
	277
585b954e SO	278	static int pgid_is_reset(struct pgid *p)
	279	{
	280	char *c;
	281
	282	for (c = (char )p + 1; c < (char )(p + 1); c++) {
	283	if (*c != 0)
	284	return 0;
	285	}
	286	return 1;
	287	}
	288
9679baaf PO	289	static int pgid_cmp(struct pgid p1, struct pgid p2)
	290	{
	291	return memcmp((char ) p1 + 1, (char ) p2 + 1,
	292	sizeof(struct pgid) - 1);
1da177e4 LT	293	}
1da177e4 LT	294
7e560814	295	/*
9679baaf	296	* Determine pathgroup state from PGID data.
7e560814	297	*/
9679baaf	298	static void pgid_analyze(struct ccw_device cdev, struct pgid *p,
d99e79ec	299	int mismatch, u8 reserved, u8 *reset)
7e560814	300	{
9679baaf PO	301	struct pgid *pgid = &cdev->private->pgid[0];
	302	struct pgid *first = NULL;
	303	int lpm;
	304	int i;
	305
	306	*mismatch = 0;
	307	*reserved = 0;
	308	*reset = 0;
	309	for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {
	310	if ((cdev->private->pgid_valid_mask & lpm) == 0)
	311	continue;
	312	if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)
d99e79ec	313	*reserved \|= lpm;
585b954e SO	314	if (pgid_is_reset(pgid)) {
585b954e SO	315	*reset \|= lpm;
9679baaf	316	continue;
d23861ff	317	}
9679baaf PO	318	if (!first) {
	319	first = pgid;
	320	continue;
	321	}
	322	if (pgid_cmp(pgid, first) != 0)
	323	*mismatch = 1;
7e560814	324	}
9679baaf PO	325	if (!first)
	326	first = &channel_subsystems[0]->global_pgid;
	327	*p = first;
7e560814 CH	328	}
7e560814 CH	329
d302e1a5	330	static u8 pgid_to_donepm(struct ccw_device *cdev)
52ef0608 PO	331	{
	332	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	333	struct pgid *pgid;
	334	int i;
	335	int lpm;
d302e1a5	336	u8 donepm = 0;
52ef0608	337
d302e1a5	338	/* Set bits for paths which are already in the target state. */
52ef0608 PO	339	for (i = 0; i < 8; i++) {
	340	lpm = 0x80 >> i;
	341	if ((cdev->private->pgid_valid_mask & lpm) == 0)
	342	continue;
	343	pgid = &cdev->private->pgid[i];
	344	if (sch->opm & lpm) {
	345	if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED)
	346	continue;
	347	} else {
	348	if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED)
	349	continue;
	350	}
	351	if (cdev->private->flags.mpath) {
	352	if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH)
	353	continue;
	354	} else {
	355	if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH)
	356	continue;
	357	}
d302e1a5	358	donepm \|= lpm;
52ef0608 PO	359	}
52ef0608 PO	360
d302e1a5	361	return donepm;
52ef0608 PO	362	}
52ef0608 PO	363
9679baaf	364	static void pgid_fill(struct ccw_device cdev, struct pgid pgid)
1da177e4	365	{
9679baaf PO	366	int i;
	367
	368	for (i = 0; i < 8; i++)
	369	memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid));
	370	}
	371
	372	/*
	373	* Process SENSE PGID data and report result.
	374	*/
	375	static void snid_done(struct ccw_device *cdev, int rc)
	376	{
	377	struct ccw_dev_id *id = &cdev->private->dev_id;
52ef0608	378	struct subchannel *sch = to_subchannel(cdev->dev.parent);
9679baaf PO	379	struct pgid *pgid;
9679baaf PO	380	int mismatch = 0;
d99e79ec	381	u8 reserved = 0;
585b954e	382	u8 reset = 0;
d302e1a5	383	u8 donepm;
9679baaf PO	384
	385	if (rc)
	386	goto out;
	387	pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);
d99e79ec	388	if (reserved == cdev->private->pgid_valid_mask)
9679baaf	389	rc = -EUSERS;
52ef0608 PO	390	else if (mismatch)
	391	rc = -EOPNOTSUPP;
	392	else {
d302e1a5 PO	393	donepm = pgid_to_donepm(cdev);
d302e1a5 PO	394	sch->vpm = donepm & sch->opm;
585b954e	395	cdev->private->pgid_reset_mask \|= reset;
e6a0b7c9 SO	396	cdev->private->pgid_todo_mask &=
e6a0b7c9 SO	397	~(donepm \| cdev->private->path_noirq_mask);
52ef0608 PO	398	pgid_fill(cdev, pgid);
52ef0608 PO	399	}
9679baaf	400	out:
52ef0608	401	CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x "
d99e79ec	402	"todo=%02x mism=%d rsvd=%02x reset=%02x\n", id->ssid,
d302e1a5 PO	403	id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,
d302e1a5 PO	404	cdev->private->pgid_todo_mask, mismatch, reserved, reset);
52ef0608 PO	405	switch (rc) {
52ef0608 PO	406	case 0:
88e7616e SO	407	if (cdev->private->flags.pgid_unknown) {
	408	pgid_wipeout_start(cdev);
	409	return;
	410	}
52ef0608	411	/* Anything left to do? */
d302e1a5	412	if (cdev->private->pgid_todo_mask == 0) {
52ef0608 PO	413	verify_done(cdev, sch->vpm == 0 ? -EACCES : 0);
	414	return;
	415	}
	416	/* Perform path-grouping. */
	417	spid_start(cdev);
	418	break;
	419	case -EOPNOTSUPP:
	420	/* Path-grouping not supported. */
	421	cdev->private->flags.pgroup = 0;
	422	cdev->private->flags.mpath = 0;
	423	verify_start(cdev);
	424	break;
	425	default:
	426	verify_done(cdev, rc);
	427	}
1da177e4	428	}
9679baaf	429
1da177e4	430	/*
9679baaf	431	* Create channel program to perform a SENSE PGID on a single path.
1da177e4	432	*/
9679baaf	433	static void snid_build_cp(struct ccw_device *cdev)
1da177e4	434	{
9679baaf PO	435	struct ccw_request *req = &cdev->private->req;
	436	struct ccw1 *cp = cdev->private->iccws;
	437	int i = 8 - ffs(req->lpm);
	438
	439	/* Channel program setup. */
	440	cp->cmd_code = CCW_CMD_SENSE_PGID;
	441	cp->cda = (u32) (addr_t) &cdev->private->pgid[i];
	442	cp->count = sizeof(struct pgid);
	443	cp->flags = CCW_FLAG_SLI;
	444	req->cp = cp;
	445	}
1da177e4	446
9679baaf PO	447	/*
	448	* Perform SENSE PGID on a single path.
	449	*/
	450	static void snid_do(struct ccw_device *cdev)
	451	{
	452	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	453	struct ccw_request *req = &cdev->private->req;
88e7616e	454	int ret;
9679baaf	455
e6a0b7c9 SO	456	req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam &
e6a0b7c9 SO	457	~cdev->private->path_noirq_mask);
9679baaf PO	458	if (!req->lpm)
	459	goto out_nopath;
	460	snid_build_cp(cdev);
	461	ccw_request_start(cdev);
	462	return;
	463
	464	out_nopath:
88e7616e SO	465	if (cdev->private->pgid_valid_mask)
	466	ret = 0;
	467	else if (cdev->private->path_noirq_mask)
	468	ret = -ETIME;
	469	else
	470	ret = -EACCES;
	471	snid_done(cdev, ret);
9679baaf	472	}
7b7db1b5	473
9679baaf PO	474	/*
	475	* Process SENSE PGID request result for single path.
	476	*/
	477	static void snid_callback(struct ccw_device cdev, void data, int rc)
	478	{
	479	struct ccw_request *req = &cdev->private->req;
	480
69f5576f SO	481	switch (rc) {
69f5576f SO	482	case 0:
9679baaf	483	cdev->private->pgid_valid_mask \|= req->lpm;
69f5576f SO	484	break;
	485	case -ETIME:
	486	cdev->private->flags.pgid_unknown = 1;
	487	cdev->private->path_noirq_mask \|= req->lpm;
	488	break;
	489	case -EACCES:
	490	cdev->private->path_notoper_mask \|= req->lpm;
	491	break;
	492	default:
9679baaf	493	goto err;
69f5576f SO	494	}
69f5576f SO	495	/* Continue on the next path. */
9679baaf PO	496	req->lpm >>= 1;
	497	snid_do(cdev);
	498	return;
	499
	500	err:
	501	snid_done(cdev, rc);
	502	}
28bdc6f6	503
9679baaf PO	504	/*
	505	* Perform path verification.
	506	*/
	507	static void verify_start(struct ccw_device *cdev)
1da177e4	508	{
6810a2bc	509	struct subchannel *sch = to_subchannel(cdev->dev.parent);
9679baaf	510	struct ccw_request *req = &cdev->private->req;
52ef0608	511	struct ccw_dev_id *devid = &cdev->private->dev_id;
6810a2bc	512
28bdc6f6	513	sch->vpm = 0;
d302e1a5	514	sch->lpm = sch->schib.pmcw.pam;
69f5576f SO	515
	516	/* Initialize PGID data. */
	517	memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid));
	518	cdev->private->pgid_valid_mask = 0;
	519	cdev->private->pgid_todo_mask = sch->schib.pmcw.pam;
	520	cdev->private->path_notoper_mask = 0;
	521
9679baaf PO	522	/* Initialize request data. */
	523	memset(req, 0, sizeof(*req));
	524	req->timeout = PGID_TIMEOUT;
	525	req->maxretries = PGID_RETRIES;
	526	req->lpm = 0x80;
982bdf81	527	req->singlepath = 1;
454e1fa1	528	if (cdev->private->flags.pgroup) {
52ef0608 PO	529	CIO_TRACE_EVENT(4, "snid");
	530	CIO_HEX_EVENT(4, devid, sizeof(*devid));
	531	req->callback = snid_callback;
	532	snid_do(cdev);
9679baaf	533	} else {
52ef0608 PO	534	CIO_TRACE_EVENT(4, "nop");
52ef0608 PO	535	CIO_HEX_EVENT(4, devid, sizeof(*devid));
9679baaf PO	536	req->filter = nop_filter;
	537	req->callback = nop_callback;
	538	nop_do(cdev);
6810a2bc	539	}
1da177e4 LT	540	}
1da177e4 LT	541
9679baaf PO	542	/**
	543	* ccw_device_verify_start - perform path verification
	544	* @cdev: ccw device
	545	*
	546	* Perform an I/O on each available channel path to @cdev to determine which
	547	* paths are operational. The resulting path mask is stored in sch->vpm.
	548	* If device options specify pathgrouping, establish a pathgroup for the
	549	* operational paths. When finished, call ccw_device_verify_done with a
	550	* return code specifying the result.
	551	*/
	552	void ccw_device_verify_start(struct ccw_device *cdev)
1da177e4	553	{
9679baaf PO	554	CIO_TRACE_EVENT(4, "vrfy");
9679baaf PO	555	CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
52ef0608 PO	556	/*
	557	* Initialize pathgroup and multipath state with target values.
	558	* They may change in the course of path verification.
	559	*/
	560	cdev->private->flags.pgroup = cdev->private->options.pgroup;
	561	cdev->private->flags.mpath = cdev->private->options.mpath;
9679baaf	562	cdev->private->flags.doverify = 0;
69f5576f	563	cdev->private->path_noirq_mask = 0;
9679baaf	564	verify_start(cdev);
1da177e4 LT	565	}
	566
	567	/*
9679baaf	568	* Process disband SET PGID request result.
1da177e4	569	*/
9679baaf	570	static void disband_callback(struct ccw_device cdev, void data, int rc)
1da177e4	571	{
9679baaf PO	572	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	573	struct ccw_dev_id *id = &cdev->private->dev_id;
	574
	575	if (rc)
	576	goto out;
	577	/* Ensure consistent multipathing state at device and channel. */
454e1fa1	578	cdev->private->flags.mpath = 0;
9679baaf PO	579	if (sch->config.mp) {
	580	sch->config.mp = 0;
	581	rc = cio_commit_config(sch);
1da177e4	582	}
9679baaf PO	583	out:
	584	CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,
	585	rc);
	586	ccw_device_disband_done(cdev, rc);
1da177e4 LT	587	}
1da177e4 LT	588
9679baaf PO	589	/**
	590	* ccw_device_disband_start - disband pathgroup
	591	* @cdev: ccw device
	592	*
	593	* Execute a SET PGID channel program on @cdev to disband a previously
	594	* established pathgroup. When finished, call ccw_device_disband_done with
	595	* a return code specifying the result.
	596	*/
	597	void ccw_device_disband_start(struct ccw_device *cdev)
1da177e4	598	{
9679baaf PO	599	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	600	struct ccw_request *req = &cdev->private->req;
	601	u8 fn;
	602
	603	CIO_TRACE_EVENT(4, "disb");
	604	CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
	605	/* Request setup. */
	606	memset(req, 0, sizeof(*req));
	607	req->timeout = PGID_TIMEOUT;
	608	req->maxretries = PGID_RETRIES;
	609	req->lpm = sch->schib.pmcw.pam & sch->opm;
982bdf81	610	req->singlepath = 1;
9679baaf PO	611	req->callback = disband_callback;
9679baaf PO	612	fn = SPID_FUNC_DISBAND;
454e1fa1	613	if (cdev->private->flags.mpath)
9679baaf PO	614	fn \|= SPID_FUNC_MULTI_PATH;
	615	spid_build_cp(cdev, fn);
	616	ccw_request_start(cdev);
1da177e4	617	}
d7d12ef2 PO	618
	619	static void stlck_build_cp(struct ccw_device cdev, void buf1, void *buf2)
	620	{
	621	struct ccw_request *req = &cdev->private->req;
	622	struct ccw1 *cp = cdev->private->iccws;
	623
	624	cp[0].cmd_code = CCW_CMD_STLCK;
	625	cp[0].cda = (u32) (addr_t) buf1;
	626	cp[0].count = 32;
	627	cp[0].flags = CCW_FLAG_CC;
	628	cp[1].cmd_code = CCW_CMD_RELEASE;
	629	cp[1].cda = (u32) (addr_t) buf2;
	630	cp[1].count = 32;
	631	cp[1].flags = 0;
	632	req->cp = cp;
	633	}
	634
	635	static void stlck_callback(struct ccw_device cdev, void data, int rc)
	636	{
	637	ccw_device_stlck_done(cdev, data, rc);
	638	}
	639
	640	/**
	641	* ccw_device_stlck_start - perform unconditional release
	642	* @cdev: ccw device
	643	* @data: data pointer to be passed to ccw_device_stlck_done
	644	* @buf1: data pointer used in channel program
	645	* @buf2: data pointer used in channel program
	646	*
	647	* Execute a channel program on @cdev to release an existing PGID reservation.
	648	* When finished, call ccw_device_stlck_done with a return code specifying the
	649	* result.
	650	*/
	651	void ccw_device_stlck_start(struct ccw_device cdev, void data, void *buf1,
	652	void *buf2)
	653	{
	654	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	655	struct ccw_request *req = &cdev->private->req;
	656
	657	CIO_TRACE_EVENT(4, "stlck");
	658	CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
	659	/* Request setup. */
	660	memset(req, 0, sizeof(*req));
	661	req->timeout = PGID_TIMEOUT;
	662	req->maxretries = PGID_RETRIES;
	663	req->lpm = sch->schib.pmcw.pam & sch->opm;
	664	req->data = data;
	665	req->callback = stlck_callback;
	666	stlck_build_cp(cdev, buf1, buf2);
	667	ccw_request_start(cdev);
	668	}
	669