[linux-2.6-block.git] / drivers / s390 / scsi / zfcp_aux.c

// SPDX-License-Identifier: GPL-2.0
/*
 * zfcp device driver
 *
 * Module interface and handling of zfcp data structures.
 *
 * Copyright IBM Corp. 2002, 2020
 */

/*
 * Driver authors:
 *            Martin Peschke (originator of the driver)
 *            Raimund Schroeder
 *            Aron Zeh
 *            Wolfgang Taphorn
 *            Stefan Bader
 *            Heiko Carstens (kernel 2.6 port of the driver)
 *            Andreas Herrmann
 *            Maxim Shchetynin
 *            Volker Sameske
 *            Ralph Wuerthner
 *            Michael Loehr
 *            Swen Schillig
 *            Christof Schmitt
 *            Martin Petermann
 *            Sven Schuetz
 *            Steffen Maier
 *	      Benjamin Block
 */

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

#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/module.h>
#include "zfcp_ext.h"
#include "zfcp_fc.h"
#include "zfcp_reqlist.h"
#include "zfcp_diag.h"

#define ZFCP_BUS_ID_SIZE	20

MODULE_AUTHOR("IBM Corporation");
MODULE_DESCRIPTION("FCP HBA driver");
MODULE_LICENSE("GPL");

static char *init_device;
module_param_named(device, init_device, charp, 0400);
MODULE_PARM_DESC(device, "specify initial device");

static struct kmem_cache * __init zfcp_cache_hw_align(const char *name,
						      unsigned long size)
{
	return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL);
}

static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
{
	struct ccw_device *cdev;
	struct zfcp_adapter *adapter;
	struct zfcp_port *port;

	cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
	if (!cdev)
		return;

	if (ccw_device_set_online(cdev))
		goto out_ccw_device;

	adapter = zfcp_ccw_adapter_by_cdev(cdev);
	if (!adapter)
		goto out_ccw_device;

	port = zfcp_get_port_by_wwpn(adapter, wwpn);
	if (!port)
		goto out_port;
	flush_work(&port->rport_work);

	zfcp_unit_add(port, lun);
	put_device(&port->dev);

out_port:
	zfcp_ccw_adapter_put(adapter);
out_ccw_device:
	put_device(&cdev->dev);
	return;
}

static void __init zfcp_init_device_setup(char *devstr)
{
	char *token;
	char *str, *str_saved;
	char busid[ZFCP_BUS_ID_SIZE];
	u64 wwpn, lun;

	/* duplicate devstr and keep the original for sysfs presentation*/
	str_saved = kstrdup(devstr, GFP_KERNEL);
	str = str_saved;
	if (!str)
		return;

	token = strsep(&str, ",");
	if (!token || strlen(token) >= ZFCP_BUS_ID_SIZE)
		goto err_out;
	strscpy(busid, token, ZFCP_BUS_ID_SIZE);

	token = strsep(&str, ",");
	if (!token || kstrtoull(token, 0, (unsigned long long *) &wwpn))
		goto err_out;

	token = strsep(&str, ",");
	if (!token || kstrtoull(token, 0, (unsigned long long *) &lun))
		goto err_out;

	kfree(str_saved);
	zfcp_init_device_configure(busid, wwpn, lun);
	return;

err_out:
	kfree(str_saved);
	pr_err("%s is not a valid SCSI device\n", devstr);
}

static int __init zfcp_module_init(void)
{
	int retval = -ENOMEM;

	if (zfcp_experimental_dix)
		pr_warn("DIX is enabled. It is experimental and might cause problems\n");

	zfcp_fsf_qtcb_cache = zfcp_cache_hw_align("zfcp_fsf_qtcb",
						  sizeof(struct fsf_qtcb));
	if (!zfcp_fsf_qtcb_cache)
		goto out_qtcb_cache;

	zfcp_fc_req_cache = zfcp_cache_hw_align("zfcp_fc_req",
						sizeof(struct zfcp_fc_req));
	if (!zfcp_fc_req_cache)
		goto out_fc_cache;

	zfcp_scsi_transport_template =
		fc_attach_transport(&zfcp_transport_functions);
	if (!zfcp_scsi_transport_template)
		goto out_transport;
	scsi_transport_reserve_device(zfcp_scsi_transport_template,
				      sizeof(struct zfcp_scsi_dev));

	retval = ccw_driver_register(&zfcp_ccw_driver);
	if (retval) {
		pr_err("The zfcp device driver could not register with "
		       "the common I/O layer\n");
		goto out_ccw_register;
	}

	if (init_device)
		zfcp_init_device_setup(init_device);
	return 0;

out_ccw_register:
	fc_release_transport(zfcp_scsi_transport_template);
out_transport:
	kmem_cache_destroy(zfcp_fc_req_cache);
out_fc_cache:
	kmem_cache_destroy(zfcp_fsf_qtcb_cache);
out_qtcb_cache:
	return retval;
}

module_init(zfcp_module_init);

static void __exit zfcp_module_exit(void)
{
	ccw_driver_unregister(&zfcp_ccw_driver);
	fc_release_transport(zfcp_scsi_transport_template);
	kmem_cache_destroy(zfcp_fc_req_cache);
	kmem_cache_destroy(zfcp_fsf_qtcb_cache);
}

module_exit(zfcp_module_exit);

/**
 * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn
 * @adapter: pointer to adapter to search for port
 * @wwpn: wwpn to search for
 *
 * Returns: pointer to zfcp_port or NULL
 */
struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
					u64 wwpn)
{
	unsigned long flags;
	struct zfcp_port *port;

	read_lock_irqsave(&adapter->port_list_lock, flags);
	list_for_each_entry(port, &adapter->port_list, list)
		if (port->wwpn == wwpn) {
			if (!get_device(&port->dev))
				port = NULL;
			read_unlock_irqrestore(&adapter->port_list_lock, flags);
			return port;
		}
	read_unlock_irqrestore(&adapter->port_list_lock, flags);
	return NULL;
}

static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
{
	adapter->pool.erp_req =
		mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
	if (!adapter->pool.erp_req)
		return -ENOMEM;

	adapter->pool.gid_pn_req =
		mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
	if (!adapter->pool.gid_pn_req)
		return -ENOMEM;

	adapter->pool.scsi_req =
		mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
	if (!adapter->pool.scsi_req)
		return -ENOMEM;

	adapter->pool.scsi_abort =
		mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
	if (!adapter->pool.scsi_abort)
		return -ENOMEM;

	adapter->pool.status_read_req =
		mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM,
					    sizeof(struct zfcp_fsf_req));
	if (!adapter->pool.status_read_req)
		return -ENOMEM;

	adapter->pool.qtcb_pool =
		mempool_create_slab_pool(4, zfcp_fsf_qtcb_cache);
	if (!adapter->pool.qtcb_pool)
		return -ENOMEM;

	BUILD_BUG_ON(sizeof(struct fsf_status_read_buffer) > PAGE_SIZE);
	adapter->pool.sr_data =
		mempool_create_page_pool(FSF_STATUS_READS_RECOM, 0);
	if (!adapter->pool.sr_data)
		return -ENOMEM;

	adapter->pool.gid_pn =
		mempool_create_slab_pool(1, zfcp_fc_req_cache);
	if (!adapter->pool.gid_pn)
		return -ENOMEM;

	return 0;
}

static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
{
	mempool_destroy(adapter->pool.erp_req);
	mempool_destroy(adapter->pool.scsi_req);
	mempool_destroy(adapter->pool.scsi_abort);
	mempool_destroy(adapter->pool.qtcb_pool);
	mempool_destroy(adapter->pool.status_read_req);
	mempool_destroy(adapter->pool.sr_data);
	mempool_destroy(adapter->pool.gid_pn);
}

/**
 * zfcp_status_read_refill - refill the long running status_read_requests
 * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled
 *
 * Return:
 * * 0 on success meaning at least one status read is pending
 * * 1 if posting failed and not a single status read buffer is pending,
 *     also triggers adapter reopen recovery
 */
int zfcp_status_read_refill(struct zfcp_adapter *adapter)
{
	while (atomic_add_unless(&adapter->stat_miss, -1, 0))
		if (zfcp_fsf_status_read(adapter->qdio)) {
			atomic_inc(&adapter->stat_miss); /* undo add -1 */
			if (atomic_read(&adapter->stat_miss) >=
			    adapter->stat_read_buf_num) {
				zfcp_erp_adapter_reopen(adapter, 0, "axsref1");
				return 1;
			}
			break;
		}
	return 0;
}

static void _zfcp_status_read_scheduler(struct work_struct *work)
{
	zfcp_status_read_refill(container_of(work, struct zfcp_adapter,
					     stat_work));
}

static void zfcp_version_change_lost_work(struct work_struct *work)
{
	struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
						    version_change_lost_work);

	zfcp_fsf_exchange_config_data_sync(adapter->qdio, NULL);
}

static void zfcp_print_sl(struct seq_file *m, struct service_level *sl)
{
	struct zfcp_adapter *adapter =
		container_of(sl, struct zfcp_adapter, service_level);

	seq_printf(m, "zfcp: %s microcode level %x\n",
		   dev_name(&adapter->ccw_device->dev),
		   adapter->fsf_lic_version);
}

static int zfcp_setup_adapter_work_queue(struct zfcp_adapter *adapter)
{
	adapter->work_queue =
		alloc_ordered_workqueue("zfcp_q_%s", WQ_MEM_RECLAIM,
					dev_name(&adapter->ccw_device->dev));
	if (!adapter->work_queue)
		return -ENOMEM;

	return 0;
}

static void zfcp_destroy_adapter_work_queue(struct zfcp_adapter *adapter)
{
	if (adapter->work_queue)
		destroy_workqueue(adapter->work_queue);
	adapter->work_queue = NULL;

}

/**
 * zfcp_adapter_enqueue - enqueue a new adapter to the list
 * @ccw_device: pointer to the struct cc_device
 *
 * Returns:	struct zfcp_adapter*
 * Enqueues an adapter at the end of the adapter list in the driver data.
 * All adapter internal structures are set up.
 * Proc-fs entries are also created.
 */
struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device)
{
	struct zfcp_adapter *adapter;

	if (!get_device(&ccw_device->dev))
		return ERR_PTR(-ENODEV);

	adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL);
	if (!adapter) {
		put_device(&ccw_device->dev);
		return ERR_PTR(-ENOMEM);
	}

	kref_init(&adapter->ref);

	ccw_device->handler = NULL;
	adapter->ccw_device = ccw_device;

	INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
	INIT_DELAYED_WORK(&adapter->scan_work, zfcp_fc_scan_ports);
	INIT_WORK(&adapter->ns_up_work, zfcp_fc_sym_name_update);
	INIT_WORK(&adapter->version_change_lost_work,
		  zfcp_version_change_lost_work);

	adapter->next_port_scan = jiffies;

	adapter->erp_action.adapter = adapter;

	if (zfcp_diag_adapter_setup(adapter))
		goto failed;

	if (zfcp_qdio_setup(adapter))
		goto failed;

	if (zfcp_allocate_low_mem_buffers(adapter))
		goto failed;

	adapter->req_list = zfcp_reqlist_alloc();
	if (!adapter->req_list)
		goto failed;

	if (zfcp_dbf_adapter_register(adapter))
		goto failed;

	if (zfcp_setup_adapter_work_queue(adapter))
		goto failed;

	if (zfcp_fc_gs_setup(adapter))
		goto failed;

	rwlock_init(&adapter->port_list_lock);
	INIT_LIST_HEAD(&adapter->port_list);

	INIT_LIST_HEAD(&adapter->events.list);
	INIT_WORK(&adapter->events.work, zfcp_fc_post_event);
	spin_lock_init(&adapter->events.list_lock);

	init_waitqueue_head(&adapter->erp_ready_wq);
	init_waitqueue_head(&adapter->erp_done_wqh);

	INIT_LIST_HEAD(&adapter->erp_ready_head);
	INIT_LIST_HEAD(&adapter->erp_running_head);

	rwlock_init(&adapter->erp_lock);
	rwlock_init(&adapter->abort_lock);

	if (zfcp_erp_thread_setup(adapter))
		goto failed;

	adapter->service_level.seq_print = zfcp_print_sl;

	dev_set_drvdata(&ccw_device->dev, adapter);

	if (device_add_groups(&ccw_device->dev, zfcp_sysfs_adapter_attr_groups))
		goto err_sysfs;

	/* report size limit per scatter-gather segment */
	adapter->ccw_device->dev.dma_parms = &adapter->dma_parms;

	adapter->stat_read_buf_num = FSF_STATUS_READS_RECOM;

	return adapter;

err_sysfs:
failed:
	/* TODO: make this more fine-granular */
	cancel_delayed_work_sync(&adapter->scan_work);
	cancel_work_sync(&adapter->stat_work);
	cancel_work_sync(&adapter->ns_up_work);
	cancel_work_sync(&adapter->version_change_lost_work);
	zfcp_destroy_adapter_work_queue(adapter);

	zfcp_fc_wka_ports_force_offline(adapter->gs);
	zfcp_scsi_adapter_unregister(adapter);

	zfcp_erp_thread_kill(adapter);
	zfcp_dbf_adapter_unregister(adapter);
	zfcp_qdio_destroy(adapter->qdio);

	zfcp_ccw_adapter_put(adapter); /* final put to release */
	return ERR_PTR(-ENOMEM);
}

void zfcp_adapter_unregister(struct zfcp_adapter *adapter)
{
	struct ccw_device *cdev = adapter->ccw_device;

	cancel_delayed_work_sync(&adapter->scan_work);
	cancel_work_sync(&adapter->stat_work);
	cancel_work_sync(&adapter->ns_up_work);
	cancel_work_sync(&adapter->version_change_lost_work);
	zfcp_destroy_adapter_work_queue(adapter);

	zfcp_fc_wka_ports_force_offline(adapter->gs);
	zfcp_scsi_adapter_unregister(adapter);
	device_remove_groups(&cdev->dev, zfcp_sysfs_adapter_attr_groups);

	zfcp_erp_thread_kill(adapter);
	zfcp_dbf_adapter_unregister(adapter);
	zfcp_qdio_destroy(adapter->qdio);

	zfcp_ccw_adapter_put(adapter); /* final put to release */
}

/**
 * zfcp_adapter_release - remove the adapter from the resource list
 * @ref: pointer to struct kref
 * locks:	adapter list write lock is assumed to be held by caller
 */
void zfcp_adapter_release(struct kref *ref)
{
	struct zfcp_adapter *adapter = container_of(ref, struct zfcp_adapter,
						    ref);
	struct ccw_device *cdev = adapter->ccw_device;

	dev_set_drvdata(&adapter->ccw_device->dev, NULL);
	zfcp_fc_gs_destroy(adapter);
	zfcp_free_low_mem_buffers(adapter);
	zfcp_diag_adapter_free(adapter);
	kfree(adapter->req_list);
	kfree(adapter->fc_stats);
	kfree(adapter->stats_reset_data);
	kfree(adapter);
	put_device(&cdev->dev);
}

static void zfcp_port_release(struct device *dev)
{
	struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);

	zfcp_ccw_adapter_put(port->adapter);
	kfree(port);
}

/**
 * zfcp_port_enqueue - enqueue port to port list of adapter
 * @adapter: adapter where remote port is added
 * @wwpn: WWPN of the remote port to be enqueued
 * @status: initial status for the port
 * @d_id: destination id of the remote port to be enqueued
 * Returns: pointer to enqueued port on success, ERR_PTR on error
 *
 * All port internal structures are set up and the sysfs entry is generated.
 * d_id is used to enqueue ports with a well known address like the Directory
 * Service for nameserver lookup.
 */
struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
				     u32 status, u32 d_id)
{
	struct zfcp_port *port;
	int retval = -ENOMEM;

	kref_get(&adapter->ref);

	port = zfcp_get_port_by_wwpn(adapter, wwpn);
	if (port) {
		put_device(&port->dev);
		retval = -EEXIST;
		goto err_put;
	}

	port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
	if (!port)
		goto err_put;

	rwlock_init(&port->unit_list_lock);
	INIT_LIST_HEAD(&port->unit_list);
	atomic_set(&port->units, 0);

	INIT_WORK(&port->gid_pn_work, zfcp_fc_port_did_lookup);
	INIT_WORK(&port->test_link_work, zfcp_fc_link_test_work);
	INIT_WORK(&port->rport_work, zfcp_scsi_rport_work);

	port->adapter = adapter;
	port->d_id = d_id;
	port->wwpn = wwpn;
	port->rport_task = RPORT_NONE;
	port->dev.parent = &adapter->ccw_device->dev;
	port->dev.groups = zfcp_port_attr_groups;
	port->dev.release = zfcp_port_release;

	port->erp_action.adapter = adapter;
	port->erp_action.port = port;

	if (dev_set_name(&port->dev, "0x%016llx", (unsigned long long)wwpn)) {
		kfree(port);
		goto err_put;
	}
	retval = -EINVAL;

	if (device_register(&port->dev)) {
		put_device(&port->dev);
		goto err_out;
	}

	write_lock_irq(&adapter->port_list_lock);
	list_add_tail(&port->list, &adapter->port_list);
	write_unlock_irq(&adapter->port_list_lock);

	atomic_or(status | ZFCP_STATUS_COMMON_RUNNING, &port->status);

	return port;

err_put:
	zfcp_ccw_adapter_put(adapter);
err_out:
	return ERR_PTR(retval);
}
Commit	Line	Data
40bf411e	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/*
553448f6	3	* zfcp device driver
1da177e4	4	*
553448f6	5	* Module interface and handling of zfcp data structures.
1da177e4	6	*
d0dff2ac	7	* Copyright IBM Corp. 2002, 2020
1da177e4 LT	8	*/
1da177e4 LT	9
4a9d2d8b AH	10	/*
	11	* Driver authors:
	12	* Martin Peschke (originator of the driver)
	13	* Raimund Schroeder
	14	* Aron Zeh
	15	* Wolfgang Taphorn
	16	* Stefan Bader
	17	* Heiko Carstens (kernel 2.6 port of the driver)
	18	* Andreas Herrmann
	19	* Maxim Shchetynin
	20	* Volker Sameske
	21	* Ralph Wuerthner
553448f6 CS	22	* Michael Loehr
	23	* Swen Schillig
	24	* Christof Schmitt
	25	* Martin Petermann
	26	* Sven Schuetz
9edf7d75	27	* Steffen Maier
7e418833	28	* Benjamin Block
4a9d2d8b AH	29	*/
4a9d2d8b AH	30
ecf39d42 CS	31	#define KMSG_COMPONENT "zfcp"
	32	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	33
bd43a42b	34	#include <linux/seq_file.h>
5a0e3ad6	35	#include <linux/slab.h>
3a4c5d59	36	#include <linux/module.h>
1da177e4	37	#include "zfcp_ext.h"
dbf5dfe9	38	#include "zfcp_fc.h"
b6bd2fb9	39	#include "zfcp_reqlist.h"
7e418833	40	#include "zfcp_diag.h"
1da177e4	41
98df67b3 KS	42	#define ZFCP_BUS_ID_SIZE 20
98df67b3 KS	43
4a66f273	44	MODULE_AUTHOR("IBM Corporation");
317e6b65	45	MODULE_DESCRIPTION("FCP HBA driver");
1da177e4 LT	46	MODULE_LICENSE("GPL");
1da177e4 LT	47
3623ecba CS	48	static char *init_device;
3623ecba CS	49	module_param_named(device, init_device, charp, 0400);
1da177e4 LT	50	MODULE_PARM_DESC(device, "specify initial device");
1da177e4 LT	51
51780d2c CS	52	static struct kmem_cache * __init zfcp_cache_hw_align(const char *name,
51780d2c CS	53	unsigned long size)
a4623c46 SS	54	{
	55	return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL);
	56	}
	57
3623ecba	58	static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
1da177e4	59	{
de3dc572	60	struct ccw_device *cdev;
1da177e4 LT	61	struct zfcp_adapter *adapter;
1da177e4 LT	62	struct zfcp_port *port;
1da177e4	63
de3dc572 SS	64	cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
de3dc572 SS	65	if (!cdev)
c5afd81e CS	66	return;
c5afd81e CS	67
de3dc572 SS	68	if (ccw_device_set_online(cdev))
de3dc572 SS	69	goto out_ccw_device;
1da177e4	70
de3dc572	71	adapter = zfcp_ccw_adapter_by_cdev(cdev);
317e6b65	72	if (!adapter)
de3dc572	73	goto out_ccw_device;
c5afd81e CS	74
	75	port = zfcp_get_port_by_wwpn(adapter, wwpn);
	76	if (!port)
1da177e4	77	goto out_port;
91978465	78	flush_work(&port->rport_work);
091694a5	79
1daa4eb5	80	zfcp_unit_add(port, lun);
615f59e0	81	put_device(&port->dev);
1daa4eb5	82
317e6b65	83	out_port:
de3dc572 SS	84	zfcp_ccw_adapter_put(adapter);
	85	out_ccw_device:
	86	put_device(&cdev->dev);
1da177e4 LT	87	return;
	88	}
	89
3623ecba CS	90	static void __init zfcp_init_device_setup(char *devstr)
	91	{
	92	char *token;
d10c0858	93	char str, str_saved;
3623ecba CS	94	char busid[ZFCP_BUS_ID_SIZE];
	95	u64 wwpn, lun;
	96
	97	/* duplicate devstr and keep the original for sysfs presentation*/
674c3a99	98	str_saved = kstrdup(devstr, GFP_KERNEL);
d10c0858	99	str = str_saved;
3623ecba CS	100	if (!str)
	101	return;
	102
3623ecba CS	103	token = strsep(&str, ",");
	104	if (!token \|\| strlen(token) >= ZFCP_BUS_ID_SIZE)
	105	goto err_out;
820109fb	106	strscpy(busid, token, ZFCP_BUS_ID_SIZE);
3623ecba CS	107
3623ecba CS	108	token = strsep(&str, ",");
ee732ea8	109	if (!token \|\| kstrtoull(token, 0, (unsigned long long *) &wwpn))
3623ecba CS	110	goto err_out;
	111
	112	token = strsep(&str, ",");
ee732ea8	113	if (!token \|\| kstrtoull(token, 0, (unsigned long long *) &lun))
3623ecba CS	114	goto err_out;
3623ecba CS	115
d10c0858	116	kfree(str_saved);
3623ecba CS	117	zfcp_init_device_configure(busid, wwpn, lun);
	118	return;
	119
d10c0858 HC	120	err_out:
d10c0858 HC	121	kfree(str_saved);
3623ecba CS	122	pr_err("%s is not a valid SCSI device\n", devstr);
	123	}
	124
317e6b65	125	static int __init zfcp_module_init(void)
1da177e4	126	{
dd52e0ea	127	int retval = -ENOMEM;
dd52e0ea	128
636db60b FL	129	if (zfcp_experimental_dix)
	130	pr_warn("DIX is enabled. It is experimental and might cause problems\n");
	131
259afe2e CS	132	zfcp_fsf_qtcb_cache = zfcp_cache_hw_align("zfcp_fsf_qtcb",
	133	sizeof(struct fsf_qtcb));
	134	if (!zfcp_fsf_qtcb_cache)
a4623c46 SS	135	goto out_qtcb_cache;
a4623c46 SS	136
087897e3 CS	137	zfcp_fc_req_cache = zfcp_cache_hw_align("zfcp_fc_req",
	138	sizeof(struct zfcp_fc_req));
	139	if (!zfcp_fc_req_cache)
	140	goto out_fc_cache;
ee744622	141
1947c72a	142	zfcp_scsi_transport_template =
dd52e0ea	143	fc_attach_transport(&zfcp_transport_functions);
1947c72a	144	if (!zfcp_scsi_transport_template)
dd52e0ea	145	goto out_transport;
1947c72a	146	scsi_transport_reserve_device(zfcp_scsi_transport_template,
57c23773 CS	147	sizeof(struct zfcp_scsi_dev));
57c23773 CS	148
c1fad417	149	retval = ccw_driver_register(&zfcp_ccw_driver);
1da177e4	150	if (retval) {
ecf39d42	151	pr_err("The zfcp device driver could not register with "
ff3b24fa	152	"the common I/O layer\n");
1da177e4 LT	153	goto out_ccw_register;
	154	}
	155
3623ecba CS	156	if (init_device)
	157	zfcp_init_device_setup(init_device);
	158	return 0;
1da177e4	159
317e6b65	160	out_ccw_register:
1947c72a	161	fc_release_transport(zfcp_scsi_transport_template);
317e6b65	162	out_transport:
087897e3 CS	163	kmem_cache_destroy(zfcp_fc_req_cache);
087897e3 CS	164	out_fc_cache:
259afe2e	165	kmem_cache_destroy(zfcp_fsf_qtcb_cache);
a4623c46	166	out_qtcb_cache:
1da177e4 LT	167	return retval;
	168	}
	169
317e6b65	170	module_init(zfcp_module_init);
1da177e4	171
c1fad417 CS	172	static void __exit zfcp_module_exit(void)
	173	{
	174	ccw_driver_unregister(&zfcp_ccw_driver);
1947c72a	175	fc_release_transport(zfcp_scsi_transport_template);
087897e3	176	kmem_cache_destroy(zfcp_fc_req_cache);
259afe2e	177	kmem_cache_destroy(zfcp_fsf_qtcb_cache);
c1fad417 CS	178	}
	179
	180	module_exit(zfcp_module_exit);
	181
1da177e4 LT	182	/**
	183	* zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn
	184	* @adapter: pointer to adapter to search for port
	185	* @wwpn: wwpn to search for
317e6b65 SS	186	*
317e6b65 SS	187	* Returns: pointer to zfcp_port or NULL
1da177e4	188	*/
317e6b65	189	struct zfcp_port zfcp_get_port_by_wwpn(struct zfcp_adapter adapter,
7ba58c9c	190	u64 wwpn)
1da177e4	191	{
ecf0c772	192	unsigned long flags;
1da177e4	193	struct zfcp_port *port;
1da177e4	194
ecf0c772 SS	195	read_lock_irqsave(&adapter->port_list_lock, flags);
ecf0c772 SS	196	list_for_each_entry(port, &adapter->port_list, list)
6b183334	197	if (port->wwpn == wwpn) {
615f59e0	198	if (!get_device(&port->dev))
6b183334	199	port = NULL;
ecf0c772	200	read_unlock_irqrestore(&adapter->port_list_lock, flags);
317e6b65	201	return port;
ecf0c772 SS	202	}
ecf0c772 SS	203	read_unlock_irqrestore(&adapter->port_list_lock, flags);
317e6b65	204	return NULL;
1da177e4 LT	205	}
1da177e4 LT	206
317e6b65	207	static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
1da177e4	208	{
a4623c46 SS	209	adapter->pool.erp_req =
	210	mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
	211	if (!adapter->pool.erp_req)
1da177e4 LT	212	return -ENOMEM;
1da177e4 LT	213
799b76d0 CS	214	adapter->pool.gid_pn_req =
	215	mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
	216	if (!adapter->pool.gid_pn_req)
	217	return -ENOMEM;
	218
a4623c46 SS	219	adapter->pool.scsi_req =
	220	mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
	221	if (!adapter->pool.scsi_req)
1da177e4 LT	222	return -ENOMEM;
1da177e4 LT	223
a4623c46 SS	224	adapter->pool.scsi_abort =
	225	mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
	226	if (!adapter->pool.scsi_abort)
1da177e4 LT	227	return -ENOMEM;
1da177e4 LT	228
a4623c46	229	adapter->pool.status_read_req =
317e6b65	230	mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM,
0eaae62a	231	sizeof(struct zfcp_fsf_req));
a4623c46 SS	232	if (!adapter->pool.status_read_req)
	233	return -ENOMEM;
	234
	235	adapter->pool.qtcb_pool =
259afe2e	236	mempool_create_slab_pool(4, zfcp_fsf_qtcb_cache);
a4623c46	237	if (!adapter->pool.qtcb_pool)
1da177e4 LT	238	return -ENOMEM;
1da177e4 LT	239
c7b279ae CS	240	BUILD_BUG_ON(sizeof(struct fsf_status_read_buffer) > PAGE_SIZE);
	241	adapter->pool.sr_data =
	242	mempool_create_page_pool(FSF_STATUS_READS_RECOM, 0);
	243	if (!adapter->pool.sr_data)
1da177e4 LT	244	return -ENOMEM;
1da177e4 LT	245
dbf5dfe9	246	adapter->pool.gid_pn =
fcf7e614	247	mempool_create_slab_pool(1, zfcp_fc_req_cache);
dbf5dfe9	248	if (!adapter->pool.gid_pn)
1da177e4 LT	249	return -ENOMEM;
	250
	251	return 0;
	252	}
	253
317e6b65	254	static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
1da177e4	255	{
6be55227	256	mempool_destroy(adapter->pool.erp_req);
	257	mempool_destroy(adapter->pool.scsi_req);
	258	mempool_destroy(adapter->pool.scsi_abort);
	259	mempool_destroy(adapter->pool.qtcb_pool);
	260	mempool_destroy(adapter->pool.status_read_req);
	261	mempool_destroy(adapter->pool.sr_data);
	262	mempool_destroy(adapter->pool.gid_pn);
1da177e4 LT	263	}
1da177e4 LT	264
317e6b65 SS	265	/**
	266	* zfcp_status_read_refill - refill the long running status_read_requests
	267	* @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled
	268	*
71714553 SM	269	* Return:
	270	* * 0 on success meaning at least one status read is pending
	271	* * 1 if posting failed and not a single status read buffer is pending,
	272	* also triggers adapter reopen recovery
317e6b65	273	*/
d26ab06e SS	274	int zfcp_status_read_refill(struct zfcp_adapter *adapter)
d26ab06e SS	275	{
60a161b7	276	while (atomic_add_unless(&adapter->stat_miss, -1, 0))
564e1c86	277	if (zfcp_fsf_status_read(adapter->qdio)) {
60a161b7	278	atomic_inc(&adapter->stat_miss); /* undo add -1 */
64deb6ef CS	279	if (atomic_read(&adapter->stat_miss) >=
64deb6ef CS	280	adapter->stat_read_buf_num) {
ea4a3a6a	281	zfcp_erp_adapter_reopen(adapter, 0, "axsref1");
7afe29f7 SS	282	return 1;
7afe29f7 SS	283	}
d26ab06e	284	break;
60a161b7	285	}
d26ab06e SS	286	return 0;
	287	}
	288
	289	static void _zfcp_status_read_scheduler(struct work_struct *work)
	290	{
	291	zfcp_status_read_refill(container_of(work, struct zfcp_adapter,
	292	stat_work));
	293	}
	294
d9019631 JW	295	static void zfcp_version_change_lost_work(struct work_struct *work)
	296	{
	297	struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
	298	version_change_lost_work);
	299
	300	zfcp_fsf_exchange_config_data_sync(adapter->qdio, NULL);
	301	}
	302
bd43a42b CS	303	static void zfcp_print_sl(struct seq_file m, struct service_level sl)
	304	{
	305	struct zfcp_adapter *adapter =
	306	container_of(sl, struct zfcp_adapter, service_level);
	307
	308	seq_printf(m, "zfcp: %s microcode level %x\n",
	309	dev_name(&adapter->ccw_device->dev),
	310	adapter->fsf_lic_version);
	311	}
	312
4544683a SS	313	static int zfcp_setup_adapter_work_queue(struct zfcp_adapter *adapter)
4544683a SS	314	{
769d7fbe BB	315	adapter->work_queue =
	316	alloc_ordered_workqueue("zfcp_q_%s", WQ_MEM_RECLAIM,
	317	dev_name(&adapter->ccw_device->dev));
	318	if (!adapter->work_queue)
	319	return -ENOMEM;
4544683a	320
769d7fbe	321	return 0;
4544683a SS	322	}
	323
	324	static void zfcp_destroy_adapter_work_queue(struct zfcp_adapter *adapter)
	325	{
	326	if (adapter->work_queue)
	327	destroy_workqueue(adapter->work_queue);
	328	adapter->work_queue = NULL;
	329
	330	}
	331
317e6b65 SS	332	/**
	333	* zfcp_adapter_enqueue - enqueue a new adapter to the list
	334	* @ccw_device: pointer to the struct cc_device
	335	*
de3dc572	336	* Returns: struct zfcp_adapter*
1da177e4 LT	337	* Enqueues an adapter at the end of the adapter list in the driver data.
	338	* All adapter internal structures are set up.
	339	* Proc-fs entries are also created.
1da177e4	340	*/
de3dc572	341	struct zfcp_adapter zfcp_adapter_enqueue(struct ccw_device ccw_device)
1da177e4	342	{
1da177e4 LT	343	struct zfcp_adapter *adapter;
1da177e4 LT	344
f3450c7b	345	if (!get_device(&ccw_device->dev))
de3dc572	346	return ERR_PTR(-ENODEV);
1da177e4	347
317e6b65	348	adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL);
f3450c7b SS	349	if (!adapter) {
f3450c7b SS	350	put_device(&ccw_device->dev);
de3dc572	351	return ERR_PTR(-ENOMEM);
f3450c7b SS	352	}
	353
	354	kref_init(&adapter->ref);
1da177e4 LT	355
1da177e4 LT	356	ccw_device->handler = NULL;
1da177e4	357	adapter->ccw_device = ccw_device;
f3450c7b SS	358
f3450c7b SS	359	INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
18f87a67	360	INIT_DELAYED_WORK(&adapter->scan_work, zfcp_fc_scan_ports);
038d9446	361	INIT_WORK(&adapter->ns_up_work, zfcp_fc_sym_name_update);
d9019631 JW	362	INIT_WORK(&adapter->version_change_lost_work,
d9019631 JW	363	zfcp_version_change_lost_work);
1da177e4	364
18f87a67 MP	365	adapter->next_port_scan = jiffies;
18f87a67 MP	366
ab31fd0c SM	367	adapter->erp_action.adapter = adapter;
ab31fd0c SM	368
7e418833 BB	369	if (zfcp_diag_adapter_setup(adapter))
	370	goto failed;
	371
d5a282a1	372	if (zfcp_qdio_setup(adapter))
f3450c7b	373	goto failed;
1da177e4	374
00bab910	375	if (zfcp_allocate_low_mem_buffers(adapter))
f3450c7b	376	goto failed;
1da177e4	377
b6bd2fb9 CS	378	adapter->req_list = zfcp_reqlist_alloc();
b6bd2fb9 CS	379	if (!adapter->req_list)
f3450c7b	380	goto failed;
317e6b65	381
5771710b	382	if (zfcp_dbf_adapter_register(adapter))
f3450c7b	383	goto failed;
317e6b65	384
4544683a	385	if (zfcp_setup_adapter_work_queue(adapter))
f3450c7b	386	goto failed;
4544683a	387
d5a282a1	388	if (zfcp_fc_gs_setup(adapter))
f3450c7b	389	goto failed;
d5a282a1	390
ecf0c772 SS	391	rwlock_init(&adapter->port_list_lock);
	392	INIT_LIST_HEAD(&adapter->port_list);
	393
2d1e547f SS	394	INIT_LIST_HEAD(&adapter->events.list);
	395	INIT_WORK(&adapter->events.work, zfcp_fc_post_event);
	396	spin_lock_init(&adapter->events.list_lock);
	397
347c6a96	398	init_waitqueue_head(&adapter->erp_ready_wq);
317e6b65	399	init_waitqueue_head(&adapter->erp_done_wqh);
1da177e4	400
317e6b65 SS	401	INIT_LIST_HEAD(&adapter->erp_ready_head);
317e6b65 SS	402	INIT_LIST_HEAD(&adapter->erp_running_head);
1da177e4	403
c48a29d0	404	rwlock_init(&adapter->erp_lock);
1da177e4 LT	405	rwlock_init(&adapter->abort_lock);
1da177e4 LT	406
143bb6bf	407	if (zfcp_erp_thread_setup(adapter))
f3450c7b	408	goto failed;
1da177e4	409
bd43a42b CS	410	adapter->service_level.seq_print = zfcp_print_sl;
bd43a42b CS	411
1da177e4 LT	412	dev_set_drvdata(&ccw_device->dev, adapter);
1da177e4 LT	413
20540a56 JW	414	if (device_add_groups(&ccw_device->dev, zfcp_sysfs_adapter_attr_groups))
20540a56 JW	415	goto err_sysfs;
6028f7c4	416
68322984	417	/* report size limit per scatter-gather segment */
68322984 CS	418	adapter->ccw_device->dev.dma_parms = &adapter->dma_parms;
68322984 CS	419
9edf7d75 SM	420	adapter->stat_read_buf_num = FSF_STATUS_READS_RECOM;
9edf7d75 SM	421
d0dff2ac	422	return adapter;
1da177e4	423
20540a56	424	err_sysfs:
f3450c7b	425	failed:
ab1fa880 JW	426	/* TODO: make this more fine-granular */
	427	cancel_delayed_work_sync(&adapter->scan_work);
	428	cancel_work_sync(&adapter->stat_work);
	429	cancel_work_sync(&adapter->ns_up_work);
	430	cancel_work_sync(&adapter->version_change_lost_work);
	431	zfcp_destroy_adapter_work_queue(adapter);
	432
	433	zfcp_fc_wka_ports_force_offline(adapter->gs);
	434	zfcp_scsi_adapter_unregister(adapter);
	435
	436	zfcp_erp_thread_kill(adapter);
	437	zfcp_dbf_adapter_unregister(adapter);
	438	zfcp_qdio_destroy(adapter->qdio);
	439
	440	zfcp_ccw_adapter_put(adapter); /* final put to release */
de3dc572 SS	441	return ERR_PTR(-ENOMEM);
	442	}
	443
	444	void zfcp_adapter_unregister(struct zfcp_adapter *adapter)
	445	{
	446	struct ccw_device *cdev = adapter->ccw_device;
	447
18f87a67	448	cancel_delayed_work_sync(&adapter->scan_work);
de3dc572	449	cancel_work_sync(&adapter->stat_work);
038d9446	450	cancel_work_sync(&adapter->ns_up_work);
d9019631	451	cancel_work_sync(&adapter->version_change_lost_work);
de3dc572 SS	452	zfcp_destroy_adapter_work_queue(adapter);
	453
	454	zfcp_fc_wka_ports_force_offline(adapter->gs);
1947c72a	455	zfcp_scsi_adapter_unregister(adapter);
20540a56	456	device_remove_groups(&cdev->dev, zfcp_sysfs_adapter_attr_groups);
de3dc572 SS	457
de3dc572 SS	458	zfcp_erp_thread_kill(adapter);
ea4a3a6a	459	zfcp_dbf_adapter_unregister(adapter);
de3dc572 SS	460	zfcp_qdio_destroy(adapter->qdio);
	461
	462	zfcp_ccw_adapter_put(adapter); /* final put to release */
1da177e4 LT	463	}
1da177e4 LT	464
317e6b65	465	/**
f3450c7b SS	466	* zfcp_adapter_release - remove the adapter from the resource list
f3450c7b SS	467	* @ref: pointer to struct kref
1da177e4	468	* locks: adapter list write lock is assumed to be held by caller
1da177e4	469	*/
f3450c7b	470	void zfcp_adapter_release(struct kref *ref)
1da177e4	471	{
f3450c7b SS	472	struct zfcp_adapter *adapter = container_of(ref, struct zfcp_adapter,
f3450c7b SS	473	ref);
de3dc572	474	struct ccw_device *cdev = adapter->ccw_device;
1da177e4	475
f3450c7b	476	dev_set_drvdata(&adapter->ccw_device->dev, NULL);
d5a282a1	477	zfcp_fc_gs_destroy(adapter);
1da177e4	478	zfcp_free_low_mem_buffers(adapter);
7e418833	479	zfcp_diag_adapter_free(adapter);
317e6b65	480	kfree(adapter->req_list);
f6cd94b1 AH	481	kfree(adapter->fc_stats);
f6cd94b1 AH	482	kfree(adapter->stats_reset_data);
1da177e4	483	kfree(adapter);
de3dc572	484	put_device(&cdev->dev);
f3450c7b SS	485	}
f3450c7b SS	486
f3450c7b	487	static void zfcp_port_release(struct device *dev)
60221920	488	{
615f59e0	489	struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
f3450c7b	490
de3dc572	491	zfcp_ccw_adapter_put(port->adapter);
f3450c7b	492	kfree(port);
60221920 SS	493	}
60221920 SS	494
1da177e4 LT	495	/**
	496	* zfcp_port_enqueue - enqueue port to port list of adapter
	497	* @adapter: adapter where remote port is added
	498	* @wwpn: WWPN of the remote port to be enqueued
	499	* @status: initial status for the port
	500	* @d_id: destination id of the remote port to be enqueued
317e6b65	501	* Returns: pointer to enqueued port on success, ERR_PTR on error
1da177e4 LT	502	*
	503	* All port internal structures are set up and the sysfs entry is generated.
	504	* d_id is used to enqueue ports with a well known address like the Directory
	505	* Service for nameserver lookup.
	506	*/
7ba58c9c	507	struct zfcp_port zfcp_port_enqueue(struct zfcp_adapter adapter, u64 wwpn,
317e6b65	508	u32 status, u32 d_id)
1da177e4	509	{
3859f6a2	510	struct zfcp_port *port;
f3450c7b SS	511	int retval = -ENOMEM;
	512
	513	kref_get(&adapter->ref);
0fac3f47	514
ecf0c772 SS	515	port = zfcp_get_port_by_wwpn(adapter, wwpn);
ecf0c772 SS	516	if (port) {
615f59e0	517	put_device(&port->dev);
f3450c7b	518	retval = -EEXIST;
b481f644	519	goto err_put;
0fac3f47	520	}
1da177e4	521
317e6b65	522	port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
1da177e4	523	if (!port)
b481f644	524	goto err_put;
1da177e4	525
ecf0c772 SS	526	rwlock_init(&port->unit_list_lock);
ecf0c772 SS	527	INIT_LIST_HEAD(&port->unit_list);
d99b601b	528	atomic_set(&port->units, 0);
ecf0c772	529
799b76d0	530	INIT_WORK(&port->gid_pn_work, zfcp_fc_port_did_lookup);
8fdf30d5	531	INIT_WORK(&port->test_link_work, zfcp_fc_link_test_work);
a2fa0aed	532	INIT_WORK(&port->rport_work, zfcp_scsi_rport_work);
1da177e4 LT	533
1da177e4 LT	534	port->adapter = adapter;
317e6b65 SS	535	port->d_id = d_id;
317e6b65 SS	536	port->wwpn = wwpn;
a2fa0aed	537	port->rport_task = RPORT_NONE;
615f59e0	538	port->dev.parent = &adapter->ccw_device->dev;
83d4e1c3	539	port->dev.groups = zfcp_port_attr_groups;
615f59e0	540	port->dev.release = zfcp_port_release;
1da177e4	541
ab31fd0c SM	542	port->erp_action.adapter = adapter;
	543	port->erp_action.port = port;
	544
615f59e0	545	if (dev_set_name(&port->dev, "0x%016llx", (unsigned long long)wwpn)) {
0fac3f47	546	kfree(port);
b481f644	547	goto err_put;
0fac3f47	548	}
f3450c7b	549	retval = -EINVAL;
1da177e4	550
615f59e0 CS	551	if (device_register(&port->dev)) {
615f59e0 CS	552	put_device(&port->dev);
f3450c7b	553	goto err_out;
f4395b65	554	}
1da177e4	555
ecf0c772 SS	556	write_lock_irq(&adapter->port_list_lock);
	557	list_add_tail(&port->list, &adapter->port_list);
	558	write_unlock_irq(&adapter->port_list_lock);
	559
805de8f4	560	atomic_or(status \| ZFCP_STATUS_COMMON_RUNNING, &port->status);
317e6b65	561
1da177e4	562	return port;
1da177e4	563
b481f644	564	err_put:
de3dc572	565	zfcp_ccw_adapter_put(adapter);
b481f644	566	err_out:
f3450c7b	567	return ERR_PTR(retval);
1da177e4	568	}