[mirror_ubuntu-bionic-kernel.git] / drivers / s390 / scsi / zfcp_ccw.c

/*
 * zfcp device driver
 *
 * Registration and callback for the s390 common I/O layer.
 *
 * Copyright IBM Corporation 2002, 2008
 */

#include "zfcp_ext.h"

/**
 * zfcp_ccw_probe - probe function of zfcp driver
 * @ccw_device: pointer to belonging ccw device
 *
 * This function gets called by the common i/o layer and sets up the initial
 * data structures for each fcp adapter, which was detected by the system.
 * Also the sysfs files for this adapter will be created by this function.
 * In addition the nameserver port will be added to the ports of the adapter
 * and its sysfs representation will be created too.
 */
static int zfcp_ccw_probe(struct ccw_device *ccw_device)
{
	int retval = 0;

	down(&zfcp_data.config_sema);
	if (zfcp_adapter_enqueue(ccw_device)) {
		dev_err(&ccw_device->dev,
			"Setting up data structures for the "
			"FCP adapter failed\n");
		retval = -EINVAL;
	}
	up(&zfcp_data.config_sema);
	return retval;
}

/**
 * zfcp_ccw_remove - remove function of zfcp driver
 * @ccw_device: pointer to belonging ccw device
 *
 * This function gets called by the common i/o layer and removes an adapter
 * from the system. Task of this function is to get rid of all units and
 * ports that belong to this adapter. And in addition all resources of this
 * adapter will be freed too.
 */
static void zfcp_ccw_remove(struct ccw_device *ccw_device)
{
	struct zfcp_adapter *adapter;
	struct zfcp_port *port, *p;
	struct zfcp_unit *unit, *u;
	LIST_HEAD(unit_remove_lh);
	LIST_HEAD(port_remove_lh);

	ccw_device_set_offline(ccw_device);
	down(&zfcp_data.config_sema);
	adapter = dev_get_drvdata(&ccw_device->dev);

	write_lock_irq(&zfcp_data.config_lock);
	list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
		list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
			list_move(&unit->list, &unit_remove_lh);
			atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
					&unit->status);
		}
		list_move(&port->list, &port_remove_lh);
		atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
	}
	atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
	write_unlock_irq(&zfcp_data.config_lock);

	list_for_each_entry_safe(port, p, &port_remove_lh, list) {
		list_for_each_entry_safe(unit, u, &unit_remove_lh, list) {
			if (atomic_read(&unit->status) &
			    ZFCP_STATUS_UNIT_REGISTERED)
				scsi_remove_device(unit->device);
			zfcp_unit_dequeue(unit);
		}
		zfcp_port_dequeue(port);
	}
	wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
	zfcp_adapter_dequeue(adapter);

	up(&zfcp_data.config_sema);
}

/**
 * zfcp_ccw_set_online - set_online function of zfcp driver
 * @ccw_device: pointer to belonging ccw device
 *
 * This function gets called by the common i/o layer and sets an adapter
 * into state online. Setting an fcp device online means that it will be
 * registered with the SCSI stack, that the QDIO queues will be set up
 * and that the adapter will be opened (asynchronously).
 */
static int zfcp_ccw_set_online(struct ccw_device *ccw_device)
{
	struct zfcp_adapter *adapter;
	int retval;

	down(&zfcp_data.config_sema);
	adapter = dev_get_drvdata(&ccw_device->dev);

	retval = zfcp_erp_thread_setup(adapter);
	if (retval)
		goto out;

	retval = zfcp_adapter_scsi_register(adapter);
	if (retval)
		goto out_scsi_register;

	/* initialize request counter */
	BUG_ON(!zfcp_reqlist_isempty(adapter));
	adapter->req_no = 0;

	zfcp_erp_modify_adapter_status(adapter, 10, NULL,
				       ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 85,
				NULL);
	zfcp_erp_wait(adapter);
	up(&zfcp_data.config_sema);
	flush_work(&adapter->scan_work);
	return 0;

 out_scsi_register:
	zfcp_erp_thread_kill(adapter);
 out:
	up(&zfcp_data.config_sema);
	return retval;
}

/**
 * zfcp_ccw_set_offline - set_offline function of zfcp driver
 * @ccw_device: pointer to belonging ccw device
 *
 * This function gets called by the common i/o layer and sets an adapter
 * into state offline.
 */
static int zfcp_ccw_set_offline(struct ccw_device *ccw_device)
{
	struct zfcp_adapter *adapter;

	down(&zfcp_data.config_sema);
	adapter = dev_get_drvdata(&ccw_device->dev);
	zfcp_erp_adapter_shutdown(adapter, 0, 86, NULL);
	zfcp_erp_wait(adapter);
	zfcp_erp_thread_kill(adapter);
	up(&zfcp_data.config_sema);
	return 0;
}

/**
 * zfcp_ccw_notify - ccw notify function
 * @ccw_device: pointer to belonging ccw device
 * @event: indicates if adapter was detached or attached
 *
 * This function gets called by the common i/o layer if an adapter has gone
 * or reappeared.
 */
static int zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
{
	struct zfcp_adapter *adapter = dev_get_drvdata(&ccw_device->dev);

	switch (event) {
	case CIO_GONE:
		dev_warn(&adapter->ccw_device->dev,
			 "The FCP device has been detached\n");
		zfcp_erp_adapter_shutdown(adapter, 0, 87, NULL);
		break;
	case CIO_NO_PATH:
		dev_warn(&adapter->ccw_device->dev,
			 "The CHPID for the FCP device is offline\n");
		zfcp_erp_adapter_shutdown(adapter, 0, 88, NULL);
		break;
	case CIO_OPER:
		dev_info(&adapter->ccw_device->dev,
			 "The FCP device is operational again\n");
		zfcp_erp_modify_adapter_status(adapter, 11, NULL,
					       ZFCP_STATUS_COMMON_RUNNING,
					       ZFCP_SET);
		zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
					89, NULL);
		break;
	}
	return 1;
}

/**
 * zfcp_ccw_shutdown - handle shutdown from cio
 * @cdev: device for adapter to shutdown.
 */
static void zfcp_ccw_shutdown(struct ccw_device *cdev)
{
	struct zfcp_adapter *adapter;

	down(&zfcp_data.config_sema);
	adapter = dev_get_drvdata(&cdev->dev);
	zfcp_erp_adapter_shutdown(adapter, 0, 90, NULL);
	zfcp_erp_wait(adapter);
	up(&zfcp_data.config_sema);
}

static struct ccw_device_id zfcp_ccw_device_id[] = {
	{ CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) },
	{ CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x4) }, /* priv. */
	{},
};

MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);

static struct ccw_driver zfcp_ccw_driver = {
	.owner       = THIS_MODULE,
	.name        = "zfcp",
	.ids         = zfcp_ccw_device_id,
	.probe       = zfcp_ccw_probe,
	.remove      = zfcp_ccw_remove,
	.set_online  = zfcp_ccw_set_online,
	.set_offline = zfcp_ccw_set_offline,
	.notify      = zfcp_ccw_notify,
	.shutdown    = zfcp_ccw_shutdown,
};

/**
 * zfcp_ccw_register - ccw register function
 *
 * Registers the driver at the common i/o layer. This function will be called
 * at module load time/system start.
 */
int __init zfcp_ccw_register(void)
{
	return ccw_driver_register(&zfcp_ccw_driver);
}

/**
 * zfcp_get_adapter_by_busid - find zfcp_adapter struct
 * @busid: bus id string of zfcp adapter to find
 */
struct zfcp_adapter *zfcp_get_adapter_by_busid(char *busid)
{
	struct ccw_device *ccw_device;
	struct zfcp_adapter *adapter = NULL;

	ccw_device = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
	if (ccw_device) {
		adapter = dev_get_drvdata(&ccw_device->dev);
		put_device(&ccw_device->dev);
	}
	return adapter;
}
Commit	Line	Data
1da177e4	1	/*
fa04c281	2	* zfcp device driver
1da177e4	3	*
fa04c281	4	* Registration and callback for the s390 common I/O layer.
1da177e4	5	*
fa04c281	6	* Copyright IBM Corporation 2002, 2008
1da177e4 LT	7	*/
1da177e4 LT	8
1da177e4 LT	9	#include "zfcp_ext.h"
1da177e4 LT	10
1da177e4 LT	11	/**
	12	* zfcp_ccw_probe - probe function of zfcp driver
	13	* @ccw_device: pointer to belonging ccw device
	14	*
	15	* This function gets called by the common i/o layer and sets up the initial
	16	* data structures for each fcp adapter, which was detected by the system.
	17	* Also the sysfs files for this adapter will be created by this function.
	18	* In addition the nameserver port will be added to the ports of the adapter
	19	* and its sysfs representation will be created too.
	20	*/
fa04c281	21	static int zfcp_ccw_probe(struct ccw_device *ccw_device)
1da177e4	22	{
1da177e4 LT	23	int retval = 0;
	24
	25	down(&zfcp_data.config_sema);
317e6b65	26	if (zfcp_adapter_enqueue(ccw_device)) {
fa04c281	27	dev_err(&ccw_device->dev,
ff3b24fa CS	28	"Setting up data structures for the "
ff3b24fa CS	29	"FCP adapter failed\n");
1da177e4	30	retval = -EINVAL;
fa04c281	31	}
1da177e4 LT	32	up(&zfcp_data.config_sema);
	33	return retval;
	34	}
	35
	36	/**
	37	* zfcp_ccw_remove - remove function of zfcp driver
	38	* @ccw_device: pointer to belonging ccw device
	39	*
	40	* This function gets called by the common i/o layer and removes an adapter
	41	* from the system. Task of this function is to get rid of all units and
	42	* ports that belong to this adapter. And in addition all resources of this
	43	* adapter will be freed too.
	44	*/
fa04c281	45	static void zfcp_ccw_remove(struct ccw_device *ccw_device)
1da177e4 LT	46	{
	47	struct zfcp_adapter *adapter;
	48	struct zfcp_port port, p;
	49	struct zfcp_unit unit, u;
0406289e CS	50	LIST_HEAD(unit_remove_lh);
0406289e CS	51	LIST_HEAD(port_remove_lh);
1da177e4 LT	52
	53	ccw_device_set_offline(ccw_device);
	54	down(&zfcp_data.config_sema);
	55	adapter = dev_get_drvdata(&ccw_device->dev);
	56
1da177e4 LT	57	write_lock_irq(&zfcp_data.config_lock);
	58	list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
	59	list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
0406289e	60	list_move(&unit->list, &unit_remove_lh);
1da177e4 LT	61	atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
	62	&unit->status);
	63	}
0406289e	64	list_move(&port->list, &port_remove_lh);
1da177e4 LT	65	atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
	66	}
	67	atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
	68	write_unlock_irq(&zfcp_data.config_lock);
	69
0406289e CS	70	list_for_each_entry_safe(port, p, &port_remove_lh, list) {
0406289e CS	71	list_for_each_entry_safe(unit, u, &unit_remove_lh, list) {
44cc76f2 SS	72	if (atomic_read(&unit->status) &
44cc76f2 SS	73	ZFCP_STATUS_UNIT_REGISTERED)
e39c8877	74	scsi_remove_device(unit->device);
1da177e4 LT	75	zfcp_unit_dequeue(unit);
	76	}
	77	zfcp_port_dequeue(port);
	78	}
44cc76f2	79	wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
1da177e4 LT	80	zfcp_adapter_dequeue(adapter);
	81
	82	up(&zfcp_data.config_sema);
	83	}
	84
	85	/**
	86	* zfcp_ccw_set_online - set_online function of zfcp driver
	87	* @ccw_device: pointer to belonging ccw device
	88	*
	89	* This function gets called by the common i/o layer and sets an adapter
	90	* into state online. Setting an fcp device online means that it will be
	91	* registered with the SCSI stack, that the QDIO queues will be set up
	92	* and that the adapter will be opened (asynchronously).
	93	*/
fa04c281	94	static int zfcp_ccw_set_online(struct ccw_device *ccw_device)
1da177e4 LT	95	{
	96	struct zfcp_adapter *adapter;
	97	int retval;
	98
	99	down(&zfcp_data.config_sema);
	100	adapter = dev_get_drvdata(&ccw_device->dev);
	101
1da177e4	102	retval = zfcp_erp_thread_setup(adapter);
fa04c281	103	if (retval)
ff17a29d	104	goto out;
1da177e4 LT	105
	106	retval = zfcp_adapter_scsi_register(adapter);
	107	if (retval)
	108	goto out_scsi_register;
fea9d6c7 VS	109
	110	/* initialize request counter */
	111	BUG_ON(!zfcp_reqlist_isempty(adapter));
	112	adapter->req_no = 0;
	113
1f6f7129	114	zfcp_erp_modify_adapter_status(adapter, 10, NULL,
698ec016	115	ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
1f6f7129 MP	116	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 85,
1f6f7129 MP	117	NULL);
1da177e4	118	zfcp_erp_wait(adapter);
77fd9494 CS	119	up(&zfcp_data.config_sema);
	120	flush_work(&adapter->scan_work);
	121	return 0;
1da177e4 LT	122
	123	out_scsi_register:
	124	zfcp_erp_thread_kill(adapter);
1da177e4 LT	125	out:
	126	up(&zfcp_data.config_sema);
	127	return retval;
	128	}
	129
	130	/**
	131	* zfcp_ccw_set_offline - set_offline function of zfcp driver
	132	* @ccw_device: pointer to belonging ccw device
	133	*
	134	* This function gets called by the common i/o layer and sets an adapter
9f28745a	135	* into state offline.
1da177e4	136	*/
fa04c281	137	static int zfcp_ccw_set_offline(struct ccw_device *ccw_device)
1da177e4 LT	138	{
	139	struct zfcp_adapter *adapter;
	140
	141	down(&zfcp_data.config_sema);
	142	adapter = dev_get_drvdata(&ccw_device->dev);
1f6f7129	143	zfcp_erp_adapter_shutdown(adapter, 0, 86, NULL);
1da177e4	144	zfcp_erp_wait(adapter);
1da177e4	145	zfcp_erp_thread_kill(adapter);
1da177e4 LT	146	up(&zfcp_data.config_sema);
	147	return 0;
	148	}
	149
	150	/**
fa04c281	151	* zfcp_ccw_notify - ccw notify function
1da177e4 LT	152	* @ccw_device: pointer to belonging ccw device
	153	* @event: indicates if adapter was detached or attached
	154	*
	155	* This function gets called by the common i/o layer if an adapter has gone
	156	* or reappeared.
	157	*/
fa04c281	158	static int zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
1da177e4	159	{
f48bf7fb	160	struct zfcp_adapter *adapter = dev_get_drvdata(&ccw_device->dev);
1da177e4	161
1da177e4 LT	162	switch (event) {
1da177e4 LT	163	case CIO_GONE:
ff3b24fa CS	164	dev_warn(&adapter->ccw_device->dev,
ff3b24fa CS	165	"The FCP device has been detached\n");
1f6f7129	166	zfcp_erp_adapter_shutdown(adapter, 0, 87, NULL);
1da177e4 LT	167	break;
1da177e4 LT	168	case CIO_NO_PATH:
ff3b24fa CS	169	dev_warn(&adapter->ccw_device->dev,
ff3b24fa CS	170	"The CHPID for the FCP device is offline\n");
1f6f7129	171	zfcp_erp_adapter_shutdown(adapter, 0, 88, NULL);
1da177e4 LT	172	break;
1da177e4 LT	173	case CIO_OPER:
ff3b24fa CS	174	dev_info(&adapter->ccw_device->dev,
ff3b24fa CS	175	"The FCP device is operational again\n");
1f6f7129	176	zfcp_erp_modify_adapter_status(adapter, 11, NULL,
1da177e4 LT	177	ZFCP_STATUS_COMMON_RUNNING,
1da177e4 LT	178	ZFCP_SET);
1f6f7129 MP	179	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
1f6f7129 MP	180	89, NULL);
1da177e4 LT	181	break;
1da177e4 LT	182	}
1da177e4 LT	183	return 1;
	184	}
	185
	186	/**
fa04c281 CS	187	* zfcp_ccw_shutdown - handle shutdown from cio
fa04c281 CS	188	* @cdev: device for adapter to shutdown.
1da177e4	189	*/
fa04c281	190	static void zfcp_ccw_shutdown(struct ccw_device *cdev)
1da177e4 LT	191	{
	192	struct zfcp_adapter *adapter;
	193
	194	down(&zfcp_data.config_sema);
958974fb	195	adapter = dev_get_drvdata(&cdev->dev);
1f6f7129	196	zfcp_erp_adapter_shutdown(adapter, 0, 90, NULL);
1da177e4 LT	197	zfcp_erp_wait(adapter);
	198	up(&zfcp_data.config_sema);
	199	}
	200
fa04c281 CS	201	static struct ccw_device_id zfcp_ccw_device_id[] = {
	202	{ CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) },
	203	{ CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x4) }, /* priv. */
	204	{},
	205	};
	206
	207	MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
	208
	209	static struct ccw_driver zfcp_ccw_driver = {
	210	.owner = THIS_MODULE,
	211	.name = "zfcp",
	212	.ids = zfcp_ccw_device_id,
	213	.probe = zfcp_ccw_probe,
	214	.remove = zfcp_ccw_remove,
	215	.set_online = zfcp_ccw_set_online,
	216	.set_offline = zfcp_ccw_set_offline,
	217	.notify = zfcp_ccw_notify,
	218	.shutdown = zfcp_ccw_shutdown,
	219	};
	220
	221	/**
	222	* zfcp_ccw_register - ccw register function
	223	*
	224	* Registers the driver at the common i/o layer. This function will be called
	225	* at module load time/system start.
	226	*/
	227	int __init zfcp_ccw_register(void)
	228	{
	229	return ccw_driver_register(&zfcp_ccw_driver);
	230	}
a1b449de SS	231
	232	/**
	233	* zfcp_get_adapter_by_busid - find zfcp_adapter struct
	234	* @busid: bus id string of zfcp adapter to find
	235	*/
	236	struct zfcp_adapter zfcp_get_adapter_by_busid(char busid)
	237	{
	238	struct ccw_device *ccw_device;
	239	struct zfcp_adapter *adapter = NULL;
	240
	241	ccw_device = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
	242	if (ccw_device) {
	243	adapter = dev_get_drvdata(&ccw_device->dev);
	244	put_device(&ccw_device->dev);
	245	}
	246	return adapter;
	247	}