[linux.git] / drivers / s390 / cio / device_id.c

/*
 *  CCW device SENSE ID I/O handling.
 *
 *    Copyright IBM Corp. 2002, 2009
 *    Author(s): Cornelia Huck <[email protected]>
 *		 Martin Schwidefsky <[email protected]>
 *		 Peter Oberparleiter <[email protected]>
 */

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

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

#define SENSE_ID_RETRIES	256
#define SENSE_ID_TIMEOUT	(10 * HZ)
#define SENSE_ID_MIN_LEN	4
#define SENSE_ID_BASIC_LEN	7

/**
 * diag210_to_senseid - convert diag 0x210 data to sense id information
 * @senseid: sense id
 * @diag: diag 0x210 data
 *
 * Return 0 on success, non-zero otherwise.
 */
static int diag210_to_senseid(struct senseid *senseid, struct diag210 *diag)
{
	static struct {
		int class, type, cu_type;
	} vm_devices[] = {
		{ 0x08, 0x01, 0x3480 },
		{ 0x08, 0x02, 0x3430 },
		{ 0x08, 0x10, 0x3420 },
		{ 0x08, 0x42, 0x3424 },
		{ 0x08, 0x44, 0x9348 },
		{ 0x08, 0x81, 0x3490 },
		{ 0x08, 0x82, 0x3422 },
		{ 0x10, 0x41, 0x1403 },
		{ 0x10, 0x42, 0x3211 },
		{ 0x10, 0x43, 0x3203 },
		{ 0x10, 0x45, 0x3800 },
		{ 0x10, 0x47, 0x3262 },
		{ 0x10, 0x48, 0x3820 },
		{ 0x10, 0x49, 0x3800 },
		{ 0x10, 0x4a, 0x4245 },
		{ 0x10, 0x4b, 0x4248 },
		{ 0x10, 0x4d, 0x3800 },
		{ 0x10, 0x4e, 0x3820 },
		{ 0x10, 0x4f, 0x3820 },
		{ 0x10, 0x82, 0x2540 },
		{ 0x10, 0x84, 0x3525 },
		{ 0x20, 0x81, 0x2501 },
		{ 0x20, 0x82, 0x2540 },
		{ 0x20, 0x84, 0x3505 },
		{ 0x40, 0x01, 0x3278 },
		{ 0x40, 0x04, 0x3277 },
		{ 0x40, 0x80, 0x2250 },
		{ 0x40, 0xc0, 0x5080 },
		{ 0x80, 0x00, 0x3215 },
	};
	int i;

	/* Special case for osa devices. */
	if (diag->vrdcvcla == 0x02 && diag->vrdcvtyp == 0x20) {
		senseid->cu_type = 0x3088;
		senseid->cu_model = 0x60;
		senseid->reserved = 0xff;
		return 0;
	}
	for (i = 0; i < ARRAY_SIZE(vm_devices); i++) {
		if (diag->vrdcvcla == vm_devices[i].class &&
		    diag->vrdcvtyp == vm_devices[i].type) {
			senseid->cu_type = vm_devices[i].cu_type;
			senseid->reserved = 0xff;
			return 0;
		}
	}

	return -ENODEV;
}

/**
 * diag_get_dev_info - retrieve device information via diag 0x210
 * @cdev: ccw device
 *
 * Returns zero on success, non-zero otherwise.
 */
static int diag210_get_dev_info(struct ccw_device *cdev)
{
	struct ccw_dev_id *dev_id = &cdev->private->dev_id;
	struct senseid *senseid = &cdev->private->senseid;
	struct diag210 diag_data;
	int rc;

	if (dev_id->ssid != 0)
		return -ENODEV;
	memset(&diag_data, 0, sizeof(diag_data));
	diag_data.vrdcdvno	= dev_id->devno;
	diag_data.vrdclen	= sizeof(diag_data);
	rc = diag210(&diag_data);
	CIO_TRACE_EVENT(4, "diag210");
	CIO_HEX_EVENT(4, &rc, sizeof(rc));
	CIO_HEX_EVENT(4, &diag_data, sizeof(diag_data));
	if (rc != 0 && rc != 2)
		goto err_failed;
	if (diag210_to_senseid(senseid, &diag_data))
		goto err_unknown;
	return 0;

err_unknown:
	CIO_MSG_EVENT(0, "snsid: device 0.%x.%04x: unknown diag210 data\n",
		      dev_id->ssid, dev_id->devno);
	return -ENODEV;
err_failed:
	CIO_MSG_EVENT(0, "snsid: device 0.%x.%04x: diag210 failed (rc=%d)\n",
		      dev_id->ssid, dev_id->devno, rc);
	return -ENODEV;
}

/*
 * Initialize SENSE ID data.
 */
static void snsid_init(struct ccw_device *cdev)
{
	cdev->private->flags.esid = 0;
	memset(&cdev->private->senseid, 0, sizeof(cdev->private->senseid));
	cdev->private->senseid.cu_type = 0xffff;
}

/*
 * Check for complete SENSE ID data.
 */
static int snsid_check(struct ccw_device *cdev, void *data)
{
	struct cmd_scsw *scsw = &cdev->private->irb.scsw.cmd;
	int len = sizeof(struct senseid) - scsw->count;

	/* Check for incomplete SENSE ID data. */
	if (len < SENSE_ID_MIN_LEN)
		goto out_restart;
	if (cdev->private->senseid.cu_type == 0xffff)
		goto out_restart;
	/* Check for incompatible SENSE ID data. */
	if (cdev->private->senseid.reserved != 0xff)
		return -EOPNOTSUPP;
	/* Check for extended-identification information. */
	if (len > SENSE_ID_BASIC_LEN)
		cdev->private->flags.esid = 1;
	return 0;

out_restart:
	snsid_init(cdev);
	return -EAGAIN;
}

/*
 * Process SENSE ID request result.
 */
static void snsid_callback(struct ccw_device *cdev, void *data, int rc)
{
	struct ccw_dev_id *id = &cdev->private->dev_id;
	struct senseid *senseid = &cdev->private->senseid;
	int vm = 0;

	if (rc && MACHINE_IS_VM) {
		/* Try diag 0x210 fallback on z/VM. */
		snsid_init(cdev);
		if (diag210_get_dev_info(cdev) == 0) {
			rc = 0;
			vm = 1;
		}
	}
	CIO_MSG_EVENT(2, "snsid: device 0.%x.%04x: rc=%d %04x/%02x "
		      "%04x/%02x%s\n", id->ssid, id->devno, rc,
		      senseid->cu_type, senseid->cu_model, senseid->dev_type,
		      senseid->dev_model, vm ? " (diag210)" : "");
	ccw_device_sense_id_done(cdev, rc);
}

/**
 * ccw_device_sense_id_start - perform SENSE ID
 * @cdev: ccw device
 *
 * Execute a SENSE ID channel program on @cdev to update its sense id
 * information. When finished, call ccw_device_sense_id_done with a
 * return code specifying the result.
 */
void ccw_device_sense_id_start(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct ccw_request *req = &cdev->private->req;
	struct ccw1 *cp = cdev->private->iccws;

	CIO_TRACE_EVENT(4, "snsid");
	CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
	/* Data setup. */
	snsid_init(cdev);
	/* Channel program setup. */
	cp->cmd_code	= CCW_CMD_SENSE_ID;
	cp->cda		= (u32) (addr_t) &cdev->private->senseid;
	cp->count	= sizeof(struct senseid);
	cp->flags	= CCW_FLAG_SLI;
	/* Request setup. */
	memset(req, 0, sizeof(*req));
	req->cp		= cp;
	req->timeout	= SENSE_ID_TIMEOUT;
	req->maxretries	= SENSE_ID_RETRIES;
	req->lpm	= sch->schib.pmcw.pam & sch->opm;
	req->check	= snsid_check;
	req->callback	= snsid_callback;
	ccw_request_start(cdev);
}
Commit	Line	Data
1da177e4	1	/*
39f5360b	2	* CCW device SENSE ID I/O handling.
1da177e4	3	*
a53c8fab	4	* Copyright IBM Corp. 2002, 2009
39f5360b PO	5	* Author(s): Cornelia Huck <[email protected]>
	6	* Martin Schwidefsky <[email protected]>
	7	* Peter Oberparleiter <[email protected]>
1da177e4 LT	8	*/
1da177e4 LT	9
045236ab	10	#include <linux/kernel.h>
39f5360b PO	11	#include <linux/string.h>
	12	#include <linux/types.h>
	13	#include <linux/errno.h>
1da177e4	14	#include <asm/ccwdev.h>
39f5360b	15	#include <asm/setup.h>
1da177e4	16	#include <asm/cio.h>
0a87c5cf	17	#include <asm/diag.h>
1da177e4 LT	18
	19	#include "cio.h"
	20	#include "cio_debug.h"
1da177e4	21	#include "device.h"
cd6b4f27	22	#include "io_sch.h"
1da177e4	23
de1b0438	24	#define SENSE_ID_RETRIES 256
39f5360b PO	25	#define SENSE_ID_TIMEOUT (10 * HZ)
	26	#define SENSE_ID_MIN_LEN 4
	27	#define SENSE_ID_BASIC_LEN 7
	28
6f52ac29	29	/**
39f5360b PO	30	* diag210_to_senseid - convert diag 0x210 data to sense id information
	31	* @senseid: sense id
	32	* @diag: diag 0x210 data
6f52ac29	33	*
39f5360b	34	* Return 0 on success, non-zero otherwise.
1da177e4	35	*/
39f5360b	36	static int diag210_to_senseid(struct senseid senseid, struct diag210 diag)
1da177e4 LT	37	{
1da177e4 LT	38	static struct {
6f52ac29	39	int class, type, cu_type;
1da177e4 LT	40	} vm_devices[] = {
	41	{ 0x08, 0x01, 0x3480 },
	42	{ 0x08, 0x02, 0x3430 },
	43	{ 0x08, 0x10, 0x3420 },
	44	{ 0x08, 0x42, 0x3424 },
	45	{ 0x08, 0x44, 0x9348 },
	46	{ 0x08, 0x81, 0x3490 },
	47	{ 0x08, 0x82, 0x3422 },
	48	{ 0x10, 0x41, 0x1403 },
	49	{ 0x10, 0x42, 0x3211 },
	50	{ 0x10, 0x43, 0x3203 },
	51	{ 0x10, 0x45, 0x3800 },
	52	{ 0x10, 0x47, 0x3262 },
	53	{ 0x10, 0x48, 0x3820 },
	54	{ 0x10, 0x49, 0x3800 },
	55	{ 0x10, 0x4a, 0x4245 },
	56	{ 0x10, 0x4b, 0x4248 },
	57	{ 0x10, 0x4d, 0x3800 },
	58	{ 0x10, 0x4e, 0x3820 },
	59	{ 0x10, 0x4f, 0x3820 },
	60	{ 0x10, 0x82, 0x2540 },
	61	{ 0x10, 0x84, 0x3525 },
	62	{ 0x20, 0x81, 0x2501 },
	63	{ 0x20, 0x82, 0x2540 },
	64	{ 0x20, 0x84, 0x3505 },
	65	{ 0x40, 0x01, 0x3278 },
	66	{ 0x40, 0x04, 0x3277 },
	67	{ 0x40, 0x80, 0x2250 },
	68	{ 0x40, 0xc0, 0x5080 },
	69	{ 0x80, 0x00, 0x3215 },
	70	};
6f52ac29 PO	71	int i;
6f52ac29 PO	72
39f5360b PO	73	/* Special case for osa devices. */
	74	if (diag->vrdcvcla == 0x02 && diag->vrdcvtyp == 0x20) {
	75	senseid->cu_type = 0x3088;
	76	senseid->cu_model = 0x60;
	77	senseid->reserved = 0xff;
	78	return 0;
	79	}
	80	for (i = 0; i < ARRAY_SIZE(vm_devices); i++) {
	81	if (diag->vrdcvcla == vm_devices[i].class &&
	82	diag->vrdcvtyp == vm_devices[i].type) {
	83	senseid->cu_type = vm_devices[i].cu_type;
	84	senseid->reserved = 0xff;
	85	return 0;
	86	}
	87	}
6f52ac29	88
39f5360b	89	return -ENODEV;
6f52ac29 PO	90	}
	91
	92	/**
39f5360b PO	93	* diag_get_dev_info - retrieve device information via diag 0x210
39f5360b PO	94	* @cdev: ccw device
6f52ac29 PO	95	*
	96	* Returns zero on success, non-zero otherwise.
	97	*/
39f5360b	98	static int diag210_get_dev_info(struct ccw_device *cdev)
6f52ac29	99	{
39f5360b PO	100	struct ccw_dev_id *dev_id = &cdev->private->dev_id;
39f5360b PO	101	struct senseid *senseid = &cdev->private->senseid;
1da177e4	102	struct diag210 diag_data;
39f5360b PO	103	int rc;
	104
	105	if (dev_id->ssid != 0)
	106	return -ENODEV;
	107	memset(&diag_data, 0, sizeof(diag_data));
	108	diag_data.vrdcdvno = dev_id->devno;
	109	diag_data.vrdclen = sizeof(diag_data);
	110	rc = diag210(&diag_data);
	111	CIO_TRACE_EVENT(4, "diag210");
	112	CIO_HEX_EVENT(4, &rc, sizeof(rc));
	113	CIO_HEX_EVENT(4, &diag_data, sizeof(diag_data));
	114	if (rc != 0 && rc != 2)
	115	goto err_failed;
	116	if (diag210_to_senseid(senseid, &diag_data))
	117	goto err_unknown;
	118	return 0;
	119
	120	err_unknown:
	121	CIO_MSG_EVENT(0, "snsid: device 0.%x.%04x: unknown diag210 data\n",
	122	dev_id->ssid, dev_id->devno);
	123	return -ENODEV;
	124	err_failed:
	125	CIO_MSG_EVENT(0, "snsid: device 0.%x.%04x: diag210 failed (rc=%d)\n",
	126	dev_id->ssid, dev_id->devno, rc);
6f52ac29	127	return -ENODEV;
1da177e4 LT	128	}
	129
	130	/*
39f5360b	131	* Initialize SENSE ID data.
1da177e4	132	*/
39f5360b	133	static void snsid_init(struct ccw_device *cdev)
1da177e4	134	{
39f5360b PO	135	cdev->private->flags.esid = 0;
	136	memset(&cdev->private->senseid, 0, sizeof(cdev->private->senseid));
	137	cdev->private->senseid.cu_type = 0xffff;
1da177e4 LT	138	}
	139
	140	/*
39f5360b	141	* Check for complete SENSE ID data.
1da177e4	142	*/
39f5360b	143	static int snsid_check(struct ccw_device cdev, void data)
1da177e4	144	{
39f5360b PO	145	struct cmd_scsw *scsw = &cdev->private->irb.scsw.cmd;
	146	int len = sizeof(struct senseid) - scsw->count;
	147
	148	/* Check for incomplete SENSE ID data. */
	149	if (len < SENSE_ID_MIN_LEN)
	150	goto out_restart;
	151	if (cdev->private->senseid.cu_type == 0xffff)
	152	goto out_restart;
	153	/* Check for incompatible SENSE ID data. */
	154	if (cdev->private->senseid.reserved != 0xff)
1da177e4	155	return -EOPNOTSUPP;
39f5360b PO	156	/* Check for extended-identification information. */
	157	if (len > SENSE_ID_BASIC_LEN)
	158	cdev->private->flags.esid = 1;
	159	return 0;
cd6b4f27	160
39f5360b PO	161	out_restart:
39f5360b PO	162	snsid_init(cdev);
1da177e4 LT	163	return -EAGAIN;
	164	}
	165
	166	/*
39f5360b	167	* Process SENSE ID request result.
1da177e4	168	*/
39f5360b	169	static void snsid_callback(struct ccw_device cdev, void data, int rc)
1da177e4	170	{
39f5360b PO	171	struct ccw_dev_id *id = &cdev->private->dev_id;
	172	struct senseid *senseid = &cdev->private->senseid;
	173	int vm = 0;
	174
	175	if (rc && MACHINE_IS_VM) {
	176	/* Try diag 0x210 fallback on z/VM. */
	177	snsid_init(cdev);
	178	if (diag210_get_dev_info(cdev) == 0) {
	179	rc = 0;
	180	vm = 1;
1da177e4	181	}
1da177e4	182	}
39f5360b PO	183	CIO_MSG_EVENT(2, "snsid: device 0.%x.%04x: rc=%d %04x/%02x "
	184	"%04x/%02x%s\n", id->ssid, id->devno, rc,
	185	senseid->cu_type, senseid->cu_model, senseid->dev_type,
	186	senseid->dev_model, vm ? " (diag210)" : "");
	187	ccw_device_sense_id_done(cdev, rc);
	188	}
6f52ac29	189
39f5360b PO	190	/**
	191	* ccw_device_sense_id_start - perform SENSE ID
	192	* @cdev: ccw device
	193	*
	194	* Execute a SENSE ID channel program on @cdev to update its sense id
	195	* information. When finished, call ccw_device_sense_id_done with a
	196	* return code specifying the result.
	197	*/
	198	void ccw_device_sense_id_start(struct ccw_device *cdev)
	199	{
	200	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	201	struct ccw_request *req = &cdev->private->req;
	202	struct ccw1 *cp = cdev->private->iccws;
	203
	204	CIO_TRACE_EVENT(4, "snsid");
	205	CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
	206	/* Data setup. */
	207	snsid_init(cdev);
	208	/* Channel program setup. */
	209	cp->cmd_code = CCW_CMD_SENSE_ID;
	210	cp->cda = (u32) (addr_t) &cdev->private->senseid;
	211	cp->count = sizeof(struct senseid);
	212	cp->flags = CCW_FLAG_SLI;
	213	/* Request setup. */
	214	memset(req, 0, sizeof(*req));
	215	req->cp = cp;
	216	req->timeout = SENSE_ID_TIMEOUT;
	217	req->maxretries = SENSE_ID_RETRIES;
	218	req->lpm = sch->schib.pmcw.pam & sch->opm;
	219	req->check = snsid_check;
	220	req->callback = snsid_callback;
	221	ccw_request_start(cdev);
1da177e4	222	}