zfcp_fsf.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * zfcp device driver
   4 *
   5 * Implementation of FSF commands.
   6 *
   7 * Copyright IBM Corp. 2002, 2023
   8 */
   9
  10#define pr_fmt(fmt) "zfcp: " fmt
  11
  12#include <linux/blktrace_api.h>
  13#include <linux/jiffies.h>
  14#include <linux/types.h>
  15#include <linux/slab.h>
  16#include <scsi/fc/fc_els.h>
  17#include "zfcp_ext.h"
  18#include "zfcp_fc.h"
  19#include "zfcp_dbf.h"
  20#include "zfcp_qdio.h"
  21#include "zfcp_reqlist.h"
  22#include "zfcp_diag.h"
  23
  24/* timeout for FSF requests sent during scsi_eh: abort or FCP TMF */
  25#define ZFCP_FSF_SCSI_ER_TIMEOUT (10*HZ)
  26/* timeout for: exchange config/port data outside ERP, or open/close WKA port */
  27#define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ)
  28
  29struct kmem_cache *zfcp_fsf_qtcb_cache;
  30
  31static bool ber_stop = true;
  32module_param(ber_stop, bool, 0600);
  33MODULE_PARM_DESC(ber_stop,
  34		 "Shuts down FCP devices for FCP channels that report a bit-error count in excess of its threshold (default on)");
  35
  36static void zfcp_fsf_request_timeout_handler(struct timer_list *t)
  37{
  38	struct zfcp_fsf_req *fsf_req = timer_container_of(fsf_req, t, timer);
  39	struct zfcp_adapter *adapter = fsf_req->adapter;
  40
  41	zfcp_qdio_siosl(adapter);
  42	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
  43				"fsrth_1");
  44}
  45
  46static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
  47				 unsigned long timeout)
  48{
  49	fsf_req->timer.function = zfcp_fsf_request_timeout_handler;
  50	fsf_req->timer.expires = jiffies + timeout;
  51	add_timer(&fsf_req->timer);
  52}
  53
  54static void zfcp_fsf_start_erp_timer(struct zfcp_fsf_req *fsf_req)
  55{
  56	BUG_ON(!fsf_req->erp_action);
  57	fsf_req->timer.function = zfcp_erp_timeout_handler;
  58	fsf_req->timer.expires = jiffies + 30 * HZ;
  59	add_timer(&fsf_req->timer);
  60}
  61
  62/* association between FSF command and FSF QTCB type */
  63static u32 fsf_qtcb_type[] = {
  64	[FSF_QTCB_FCP_CMND] =             FSF_IO_COMMAND,
  65	[FSF_QTCB_ABORT_FCP_CMND] =       FSF_SUPPORT_COMMAND,
  66	[FSF_QTCB_OPEN_PORT_WITH_DID] =   FSF_SUPPORT_COMMAND,
  67	[FSF_QTCB_OPEN_LUN] =             FSF_SUPPORT_COMMAND,
  68	[FSF_QTCB_CLOSE_LUN] =            FSF_SUPPORT_COMMAND,
  69	[FSF_QTCB_CLOSE_PORT] =           FSF_SUPPORT_COMMAND,
  70	[FSF_QTCB_CLOSE_PHYSICAL_PORT] =  FSF_SUPPORT_COMMAND,
  71	[FSF_QTCB_SEND_ELS] =             FSF_SUPPORT_COMMAND,
  72	[FSF_QTCB_SEND_GENERIC] =         FSF_SUPPORT_COMMAND,
  73	[FSF_QTCB_EXCHANGE_CONFIG_DATA] = FSF_CONFIG_COMMAND,
  74	[FSF_QTCB_EXCHANGE_PORT_DATA] =   FSF_PORT_COMMAND,
  75	[FSF_QTCB_DOWNLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND,
  76	[FSF_QTCB_UPLOAD_CONTROL_FILE] =  FSF_SUPPORT_COMMAND
  77};
  78
  79static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
  80{
  81	dev_err(&req->adapter->ccw_device->dev, "FCP device not "
  82		"operational because of an unsupported FC class\n");
  83	zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1");
  84	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  85}
  86
  87/**
  88 * zfcp_fsf_req_free - free memory used by fsf request
  89 * @req: pointer to struct zfcp_fsf_req
  90 */
  91void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
  92{
  93	if (likely(req->pool)) {
  94		if (likely(!zfcp_fsf_req_is_status_read_buffer(req)))
  95			mempool_free(req->qtcb, req->adapter->pool.qtcb_pool);
  96		mempool_free(req, req->pool);
  97		return;
  98	}
  99
 100	if (likely(!zfcp_fsf_req_is_status_read_buffer(req)))
 101		kmem_cache_free(zfcp_fsf_qtcb_cache, req->qtcb);
 102	kfree(req);
 103}
 104
 105static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
 106{
 107	unsigned long flags;
 108	struct fsf_status_read_buffer *sr_buf = req->data;
 109	struct zfcp_adapter *adapter = req->adapter;
 110	struct zfcp_port *port;
 111	int d_id = ntoh24(sr_buf->d_id);
 112
 113	read_lock_irqsave(&adapter->port_list_lock, flags);
 114	list_for_each_entry(port, &adapter->port_list, list)
 115		if (port->d_id == d_id) {
 116			zfcp_erp_port_reopen(port, 0, "fssrpc1");
 117			break;
 118		}
 119	read_unlock_irqrestore(&adapter->port_list_lock, flags);
 120}
 121
 122void zfcp_fsf_fc_host_link_down(struct zfcp_adapter *adapter)
 123{
 124	struct Scsi_Host *shost = adapter->scsi_host;
 125
 126	adapter->hydra_version = 0;
 127	adapter->peer_wwpn = 0;
 128	adapter->peer_wwnn = 0;
 129	adapter->peer_d_id = 0;
 130
 131	/* if there is no shost yet, we have nothing to zero-out */
 132	if (shost == NULL)
 133		return;
 134
 135	fc_host_port_id(shost) = 0;
 136	fc_host_fabric_name(shost) = 0;
 137	fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
 138	fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
 139	snprintf(fc_host_model(shost), FC_SYMBOLIC_NAME_SIZE, "0x%04x", 0);
 140	memset(fc_host_active_fc4s(shost), 0, FC_FC4_LIST_SIZE);
 141}
 142
 143static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req,
 144					 struct fsf_link_down_info *link_down)
 145{
 146	struct zfcp_adapter *adapter = req->adapter;
 147
 148	if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
 149		return;
 150
 151	atomic_or(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
 152
 153	zfcp_scsi_schedule_rports_block(adapter);
 154
 155	zfcp_fsf_fc_host_link_down(adapter);
 156
 157	if (!link_down)
 158		goto out;
 159
 160	switch (link_down->error_code) {
 161	case FSF_PSQ_LINK_NO_LIGHT:
 162		dev_warn(&req->adapter->ccw_device->dev,
 163			 "There is no light signal from the local "
 164			 "fibre channel cable\n");
 165		break;
 166	case FSF_PSQ_LINK_WRAP_PLUG:
 167		dev_warn(&req->adapter->ccw_device->dev,
 168			 "There is a wrap plug instead of a fibre "
 169			 "channel cable\n");
 170		break;
 171	case FSF_PSQ_LINK_NO_FCP:
 172		dev_warn(&req->adapter->ccw_device->dev,
 173			 "The adjacent fibre channel node does not "
 174			 "support FCP\n");
 175		break;
 176	case FSF_PSQ_LINK_FIRMWARE_UPDATE:
 177		dev_warn(&req->adapter->ccw_device->dev,
 178			 "The FCP device is suspended because of a "
 179			 "firmware update\n");
 180		break;
 181	case FSF_PSQ_LINK_INVALID_WWPN:
 182		dev_warn(&req->adapter->ccw_device->dev,
 183			 "The FCP device detected a WWPN that is "
 184			 "duplicate or not valid\n");
 185		break;
 186	case FSF_PSQ_LINK_NO_NPIV_SUPPORT:
 187		dev_warn(&req->adapter->ccw_device->dev,
 188			 "The fibre channel fabric does not support NPIV\n");
 189		break;
 190	case FSF_PSQ_LINK_NO_FCP_RESOURCES:
 191		dev_warn(&req->adapter->ccw_device->dev,
 192			 "The FCP adapter cannot support more NPIV ports\n");
 193		break;
 194	case FSF_PSQ_LINK_NO_FABRIC_RESOURCES:
 195		dev_warn(&req->adapter->ccw_device->dev,
 196			 "The adjacent switch cannot support "
 197			 "more NPIV ports\n");
 198		break;
 199	case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE:
 200		dev_warn(&req->adapter->ccw_device->dev,
 201			 "The FCP adapter could not log in to the "
 202			 "fibre channel fabric\n");
 203		break;
 204	case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED:
 205		dev_warn(&req->adapter->ccw_device->dev,
 206			 "The WWPN assignment file on the FCP adapter "
 207			 "has been damaged\n");
 208		break;
 209	case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED:
 210		dev_warn(&req->adapter->ccw_device->dev,
 211			 "The mode table on the FCP adapter "
 212			 "has been damaged\n");
 213		break;
 214	case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT:
 215		dev_warn(&req->adapter->ccw_device->dev,
 216			 "All NPIV ports on the FCP adapter have "
 217			 "been assigned\n");
 218		break;
 219	default:
 220		dev_warn(&req->adapter->ccw_device->dev,
 221			 "The link between the FCP adapter and "
 222			 "the FC fabric is down\n");
 223	}
 224out:
 225	zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
 226}
 227
 228static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
 229{
 230	struct fsf_status_read_buffer *sr_buf = req->data;
 231	struct fsf_link_down_info *ldi =
 232		(struct fsf_link_down_info *) &sr_buf->payload;
 233
 234	switch (sr_buf->status_subtype) {
 235	case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
 236	case FSF_STATUS_READ_SUB_FDISC_FAILED:
 237		zfcp_fsf_link_down_info_eval(req, ldi);
 238		break;
 239	case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
 240		zfcp_fsf_link_down_info_eval(req, NULL);
 241	}
 242}
 243
 244static void
 245zfcp_fsf_status_read_version_change(struct zfcp_adapter *adapter,
 246				    struct fsf_status_read_buffer *sr_buf)
 247{
 248	if (sr_buf->status_subtype == FSF_STATUS_READ_SUB_LIC_CHANGE) {
 249		u32 version = sr_buf->payload.version_change.current_version;
 250
 251		WRITE_ONCE(adapter->fsf_lic_version, version);
 252		snprintf(fc_host_firmware_version(adapter->scsi_host),
 253			 FC_VERSION_STRING_SIZE, "%#08x", version);
 254	}
 255}
 256
 257static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
 258{
 259	struct zfcp_adapter *adapter = req->adapter;
 260	struct fsf_status_read_buffer *sr_buf = req->data;
 261
 262	if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
 263		zfcp_dbf_hba_fsf_uss("fssrh_1", req);
 264		mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
 265		zfcp_fsf_req_free(req);
 266		return;
 267	}
 268
 269	zfcp_dbf_hba_fsf_uss("fssrh_4", req);
 270
 271	switch (sr_buf->status_type) {
 272	case FSF_STATUS_READ_PORT_CLOSED:
 273		zfcp_fsf_status_read_port_closed(req);
 274		break;
 275	case FSF_STATUS_READ_INCOMING_ELS:
 276		zfcp_fc_incoming_els(req);
 277		break;
 278	case FSF_STATUS_READ_SENSE_DATA_AVAIL:
 279		break;
 280	case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
 281		zfcp_dbf_hba_bit_err("fssrh_3", req);
 282		if (ber_stop) {
 283			dev_warn(&adapter->ccw_device->dev,
 284				 "All paths over this FCP device are disused because of excessive bit errors\n");
 285			zfcp_erp_adapter_shutdown(adapter, 0, "fssrh_b");
 286		} else {
 287			dev_warn(&adapter->ccw_device->dev,
 288				 "The error threshold for checksum statistics has been exceeded\n");
 289		}
 290		break;
 291	case FSF_STATUS_READ_LINK_DOWN:
 292		zfcp_fsf_status_read_link_down(req);
 293		zfcp_fc_enqueue_event(adapter, FCH_EVT_LINKDOWN, 0);
 294		break;
 295	case FSF_STATUS_READ_LINK_UP:
 296		dev_info(&adapter->ccw_device->dev,
 297			 "The local link has been restored\n");
 298		/* All ports should be marked as ready to run again */
 299		zfcp_erp_set_adapter_status(adapter,
 300					    ZFCP_STATUS_COMMON_RUNNING);
 301		zfcp_erp_adapter_reopen(adapter,
 302					ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
 303					ZFCP_STATUS_COMMON_ERP_FAILED,
 304					"fssrh_2");
 305		zfcp_fc_enqueue_event(adapter, FCH_EVT_LINKUP, 0);
 306
 307		break;
 308	case FSF_STATUS_READ_NOTIFICATION_LOST:
 309		if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
 310			zfcp_fc_conditional_port_scan(adapter);
 311		if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_VERSION_CHANGE)
 312			queue_work(adapter->work_queue,
 313				   &adapter->version_change_lost_work);
 314		break;
 315	case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
 316		adapter->adapter_features = sr_buf->payload.word[0];
 317		break;
 318	case FSF_STATUS_READ_VERSION_CHANGE:
 319		zfcp_fsf_status_read_version_change(adapter, sr_buf);
 320		break;
 321	}
 322
 323	mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
 324	zfcp_fsf_req_free(req);
 325
 326	atomic_inc(&adapter->stat_miss);
 327	queue_work(adapter->work_queue, &adapter->stat_work);
 328}
 329
 330static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
 331{
 332	switch (req->qtcb->header.fsf_status_qual.word[0]) {
 333	case FSF_SQ_FCP_RSP_AVAILABLE:
 334	case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
 335	case FSF_SQ_NO_RETRY_POSSIBLE:
 336	case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
 337		return;
 338	case FSF_SQ_COMMAND_ABORTED:
 339		break;
 340	case FSF_SQ_NO_RECOM:
 341		dev_err(&req->adapter->ccw_device->dev,
 342			"The FCP adapter reported a problem "
 343			"that cannot be recovered\n");
 344		zfcp_qdio_siosl(req->adapter);
 345		zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1");
 346		break;
 347	}
 348	/* all non-return stats set FSFREQ_ERROR*/
 349	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 350}
 351
 352static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
 353{
 354	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
 355		return;
 356
 357	switch (req->qtcb->header.fsf_status) {
 358	case FSF_UNKNOWN_COMMAND:
 359		dev_err(&req->adapter->ccw_device->dev,
 360			"The FCP adapter does not recognize the command 0x%x\n",
 361			req->qtcb->header.fsf_command);
 362		zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1");
 363		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 364		break;
 365	case FSF_ADAPTER_STATUS_AVAILABLE:
 366		zfcp_fsf_fsfstatus_qual_eval(req);
 367		break;
 368	}
 369}
 370
 371static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
 372{
 373	struct zfcp_adapter *adapter = req->adapter;
 374	struct fsf_qtcb *qtcb = req->qtcb;
 375	union fsf_prot_status_qual *psq = &qtcb->prefix.prot_status_qual;
 376
 377	zfcp_dbf_hba_fsf_response(req);
 378
 379	if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
 380		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 381		return;
 382	}
 383
 384	switch (qtcb->prefix.prot_status) {
 385	case FSF_PROT_GOOD:
 386	case FSF_PROT_FSF_STATUS_PRESENTED:
 387		return;
 388	case FSF_PROT_QTCB_VERSION_ERROR:
 389		dev_err(&adapter->ccw_device->dev,
 390			"QTCB version 0x%x not supported by FCP adapter "
 391			"(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
 392			psq->word[0], psq->word[1]);
 393		zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1");
 394		break;
 395	case FSF_PROT_ERROR_STATE:
 396	case FSF_PROT_SEQ_NUMB_ERROR:
 397		zfcp_erp_adapter_reopen(adapter, 0, "fspse_2");
 398		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 399		break;
 400	case FSF_PROT_UNSUPP_QTCB_TYPE:
 401		dev_err(&adapter->ccw_device->dev,
 402			"The QTCB type is not supported by the FCP adapter\n");
 403		zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3");
 404		break;
 405	case FSF_PROT_HOST_CONNECTION_INITIALIZING:
 406		atomic_or(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 407				&adapter->status);
 408		break;
 409	case FSF_PROT_DUPLICATE_REQUEST_ID:
 410		dev_err(&adapter->ccw_device->dev,
 411			"0x%Lx is an ambiguous request identifier\n",
 412			(unsigned long long)qtcb->bottom.support.req_handle);
 413		zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4");
 414		break;
 415	case FSF_PROT_LINK_DOWN:
 416		zfcp_fsf_link_down_info_eval(req, &psq->link_down_info);
 417		/* go through reopen to flush pending requests */
 418		zfcp_erp_adapter_reopen(adapter, 0, "fspse_6");
 419		break;
 420	case FSF_PROT_REEST_QUEUE:
 421		/* All ports should be marked as ready to run again */
 422		zfcp_erp_set_adapter_status(adapter,
 423					    ZFCP_STATUS_COMMON_RUNNING);
 424		zfcp_erp_adapter_reopen(adapter,
 425					ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
 426					ZFCP_STATUS_COMMON_ERP_FAILED,
 427					"fspse_8");
 428		break;
 429	default:
 430		dev_err(&adapter->ccw_device->dev,
 431			"0x%x is not a valid transfer protocol status\n",
 432			qtcb->prefix.prot_status);
 433		zfcp_qdio_siosl(adapter);
 434		zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9");
 435	}
 436	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 437}
 438
 439/**
 440 * zfcp_fsf_req_complete - process completion of a FSF request
 441 * @req: The FSF request that has been completed.
 442 *
 443 * When a request has been completed either from the FCP adapter,
 444 * or it has been dismissed due to a queue shutdown, this function
 445 * is called to process the completion status and trigger further
 446 * events related to the FSF request.
 447 * Caller must ensure that the request has been removed from
 448 * adapter->req_list, to protect against concurrent modification
 449 * by zfcp_erp_strategy_check_fsfreq().
 450 */
 451static void zfcp_fsf_req_complete(struct zfcp_fsf_req *req)
 452{
 453	struct zfcp_erp_action *erp_action;
 454
 455	if (unlikely(zfcp_fsf_req_is_status_read_buffer(req))) {
 456		zfcp_fsf_status_read_handler(req);
 457		return;
 458	}
 459
 460	timer_delete_sync(&req->timer);
 461	zfcp_fsf_protstatus_eval(req);
 462	zfcp_fsf_fsfstatus_eval(req);
 463	req->handler(req);
 464
 465	erp_action = req->erp_action;
 466	if (erp_action)
 467		zfcp_erp_notify(erp_action, 0);
 468
 469	if (likely(req->status & ZFCP_STATUS_FSFREQ_CLEANUP))
 470		zfcp_fsf_req_free(req);
 471	else
 472		complete(&req->completion);
 473}
 474
 475/**
 476 * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
 477 * @adapter: pointer to struct zfcp_adapter
 478 *
 479 * Never ever call this without shutting down the adapter first.
 480 * Otherwise the adapter would continue using and corrupting s390 storage.
 481 * Included BUG_ON() call to ensure this is done.
 482 * ERP is supposed to be the only user of this function.
 483 */
 484void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
 485{
 486	struct zfcp_fsf_req *req, *tmp;
 487	LIST_HEAD(remove_queue);
 488
 489	BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
 490	zfcp_reqlist_move(adapter->req_list, &remove_queue);
 491
 492	list_for_each_entry_safe(req, tmp, &remove_queue, list) {
 493		list_del(&req->list);
 494		req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
 495		zfcp_fsf_req_complete(req);
 496	}
 497}
 498
 499#define ZFCP_FSF_PORTSPEED_1GBIT	(1 <<  0)
 500#define ZFCP_FSF_PORTSPEED_2GBIT	(1 <<  1)
 501#define ZFCP_FSF_PORTSPEED_4GBIT	(1 <<  2)
 502#define ZFCP_FSF_PORTSPEED_10GBIT	(1 <<  3)
 503#define ZFCP_FSF_PORTSPEED_8GBIT	(1 <<  4)
 504#define ZFCP_FSF_PORTSPEED_16GBIT	(1 <<  5)
 505#define ZFCP_FSF_PORTSPEED_32GBIT	(1 <<  6)
 506#define ZFCP_FSF_PORTSPEED_64GBIT	(1 <<  7)
 507#define ZFCP_FSF_PORTSPEED_128GBIT	(1 <<  8)
 508#define ZFCP_FSF_PORTSPEED_NOT_NEGOTIATED (1 << 15)
 509
 510u32 zfcp_fsf_convert_portspeed(u32 fsf_speed)
 511{
 512	u32 fdmi_speed = 0;
 513	if (fsf_speed & ZFCP_FSF_PORTSPEED_1GBIT)
 514		fdmi_speed |= FC_PORTSPEED_1GBIT;
 515	if (fsf_speed & ZFCP_FSF_PORTSPEED_2GBIT)
 516		fdmi_speed |= FC_PORTSPEED_2GBIT;
 517	if (fsf_speed & ZFCP_FSF_PORTSPEED_4GBIT)
 518		fdmi_speed |= FC_PORTSPEED_4GBIT;
 519	if (fsf_speed & ZFCP_FSF_PORTSPEED_10GBIT)
 520		fdmi_speed |= FC_PORTSPEED_10GBIT;
 521	if (fsf_speed & ZFCP_FSF_PORTSPEED_8GBIT)
 522		fdmi_speed |= FC_PORTSPEED_8GBIT;
 523	if (fsf_speed & ZFCP_FSF_PORTSPEED_16GBIT)
 524		fdmi_speed |= FC_PORTSPEED_16GBIT;
 525	if (fsf_speed & ZFCP_FSF_PORTSPEED_32GBIT)
 526		fdmi_speed |= FC_PORTSPEED_32GBIT;
 527	if (fsf_speed & ZFCP_FSF_PORTSPEED_64GBIT)
 528		fdmi_speed |= FC_PORTSPEED_64GBIT;
 529	if (fsf_speed & ZFCP_FSF_PORTSPEED_128GBIT)
 530		fdmi_speed |= FC_PORTSPEED_128GBIT;
 531	if (fsf_speed & ZFCP_FSF_PORTSPEED_NOT_NEGOTIATED)
 532		fdmi_speed |= FC_PORTSPEED_NOT_NEGOTIATED;
 533	return fdmi_speed;
 534}
 535
 536static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
 537{
 538	struct fsf_qtcb_bottom_config *bottom = &req->qtcb->bottom.config;
 539	struct zfcp_adapter *adapter = req->adapter;
 540	struct fc_els_flogi *plogi;
 541
 542	/* adjust pointers for missing command code */
 543	plogi = (struct fc_els_flogi *) ((u8 *)&bottom->plogi_payload
 544					- sizeof(u32));
 545
 546	if (req->data)
 547		memcpy(req->data, bottom, sizeof(*bottom));
 548
 549	adapter->timer_ticks = bottom->timer_interval & ZFCP_FSF_TIMER_INT_MASK;
 550	adapter->stat_read_buf_num = max(bottom->status_read_buf_num,
 551					 (u16)FSF_STATUS_READS_RECOM);
 552
 553	/* no error return above here, otherwise must fix call chains */
 554	/* do not evaluate invalid fields */
 555	if (req->qtcb->header.fsf_status == FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE)
 556		return 0;
 557
 558	adapter->hydra_version = bottom->adapter_type;
 559
 560	switch (bottom->fc_topology) {
 561	case FSF_TOPO_P2P:
 562		adapter->peer_d_id = ntoh24(bottom->peer_d_id);
 563		adapter->peer_wwpn = be64_to_cpu(plogi->fl_wwpn);
 564		adapter->peer_wwnn = be64_to_cpu(plogi->fl_wwnn);
 565		break;
 566	case FSF_TOPO_FABRIC:
 567		break;
 568	case FSF_TOPO_AL:
 569	default:
 570		dev_err(&adapter->ccw_device->dev,
 571			"Unknown or unsupported arbitrated loop "
 572			"fibre channel topology detected\n");
 573		zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1");
 574		return -EIO;
 575	}
 576
 577	return 0;
 578}
 579
 580static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
 581{
 582	struct zfcp_adapter *adapter = req->adapter;
 583	struct zfcp_diag_header *const diag_hdr =
 584		&adapter->diagnostics->config_data.header;
 585	struct fsf_qtcb *qtcb = req->qtcb;
 586	struct fsf_qtcb_bottom_config *bottom = &qtcb->bottom.config;
 587
 588	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
 589		return;
 590
 591	adapter->fsf_lic_version = bottom->lic_version;
 592	adapter->adapter_features = bottom->adapter_features;
 593	adapter->connection_features = bottom->connection_features;
 594	adapter->peer_wwpn = 0;
 595	adapter->peer_wwnn = 0;
 596	adapter->peer_d_id = 0;
 597
 598	switch (qtcb->header.fsf_status) {
 599	case FSF_GOOD:
 600		/*
 601		 * usually we wait with an update till the cache is too old,
 602		 * but because we have the data available, update it anyway
 603		 */
 604		zfcp_diag_update_xdata(diag_hdr, bottom, false);
 605
 606		zfcp_scsi_shost_update_config_data(adapter, bottom, false);
 607		if (zfcp_fsf_exchange_config_evaluate(req))
 608			return;
 609
 610		if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
 611			dev_err(&adapter->ccw_device->dev,
 612				"FCP adapter maximum QTCB size (%d bytes) "
 613				"is too small\n",
 614				bottom->max_qtcb_size);
 615			zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1");
 616			return;
 617		}
 618		atomic_or(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
 619				&adapter->status);
 620		break;
 621	case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
 622		zfcp_diag_update_xdata(diag_hdr, bottom, true);
 623		req->status |= ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE;
 624
 625		/* avoids adapter shutdown to be able to recognize
 626		 * events such as LINK UP */
 627		atomic_or(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
 628				&adapter->status);
 629		zfcp_fsf_link_down_info_eval(req,
 630			&qtcb->header.fsf_status_qual.link_down_info);
 631
 632		zfcp_scsi_shost_update_config_data(adapter, bottom, true);
 633		if (zfcp_fsf_exchange_config_evaluate(req))
 634			return;
 635		break;
 636	default:
 637		zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3");
 638		return;
 639	}
 640
 641	if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT)
 642		adapter->hardware_version = bottom->hardware_version;
 643
 644	if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) {
 645		dev_err(&adapter->ccw_device->dev,
 646			"The FCP adapter only supports newer "
 647			"control block versions\n");
 648		zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4");
 649		return;
 650	}
 651	if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
 652		dev_err(&adapter->ccw_device->dev,
 653			"The FCP adapter only supports older "
 654			"control block versions\n");
 655		zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5");
 656	}
 657}
 658
 659/*
 660 * Mapping of FC Endpoint Security flag masks to mnemonics
 661 *
 662 * NOTE: Update macro ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH when making any
 663 *       changes.
 664 */
 665static const struct {
 666	u32	mask;
 667	char	*name;
 668} zfcp_fsf_fc_security_mnemonics[] = {
 669	{ FSF_FC_SECURITY_AUTH,		"Authentication" },
 670	{ FSF_FC_SECURITY_ENC_FCSP2 |
 671	  FSF_FC_SECURITY_ENC_ERAS,	"Encryption" },
 672};
 673
 674/* maximum strlen(zfcp_fsf_fc_security_mnemonics[...].name) + 1 */
 675#define ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH 15
 676
 677/**
 678 * zfcp_fsf_scnprint_fc_security() - translate FC Endpoint Security flags into
 679 *                                   mnemonics and place in a buffer
 680 * @buf        : the buffer to place the translated FC Endpoint Security flag(s)
 681 *               into
 682 * @size       : the size of the buffer, including the trailing null space
 683 * @fc_security: one or more FC Endpoint Security flags, or zero
 684 * @fmt        : specifies whether a list or a single item is to be put into the
 685 *               buffer
 686 *
 687 * The Fibre Channel (FC) Endpoint Security flags are translated into mnemonics.
 688 * If the FC Endpoint Security flags are zero "none" is placed into the buffer.
 689 *
 690 * With ZFCP_FSF_PRINT_FMT_LIST the mnemonics are placed as a list separated by
 691 * a comma followed by a space into the buffer. If one or more FC Endpoint
 692 * Security flags cannot be translated into a mnemonic, as they are undefined
 693 * in zfcp_fsf_fc_security_mnemonics, their bitwise ORed value in hexadecimal
 694 * representation is placed into the buffer.
 695 *
 696 * With ZFCP_FSF_PRINT_FMT_SINGLEITEM only one single mnemonic is placed into
 697 * the buffer. If the FC Endpoint Security flag cannot be translated, as it is
 698 * undefined in zfcp_fsf_fc_security_mnemonics, its value in hexadecimal
 699 * representation is placed into the buffer. If more than one FC Endpoint
 700 * Security flag was specified, their value in hexadecimal representation is
 701 * placed into the buffer. The macro ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH
 702 * can be used to define a buffer that is large enough to hold one mnemonic.
 703 *
 704 * Return: The number of characters written into buf not including the trailing
 705 *         '\0'. If size is == 0 the function returns 0.
 706 */
 707ssize_t zfcp_fsf_scnprint_fc_security(char *buf, size_t size, u32 fc_security,
 708				      enum zfcp_fsf_print_fmt fmt)
 709{
 710	const char *prefix = "";
 711	ssize_t len = 0;
 712	int i;
 713
 714	if (fc_security == 0)
 715		return scnprintf(buf, size, "none");
 716	if (fmt == ZFCP_FSF_PRINT_FMT_SINGLEITEM && hweight32(fc_security) != 1)
 717		return scnprintf(buf, size, "0x%08x", fc_security);
 718
 719	for (i = 0; i < ARRAY_SIZE(zfcp_fsf_fc_security_mnemonics); i++) {
 720		if (!(fc_security & zfcp_fsf_fc_security_mnemonics[i].mask))
 721			continue;
 722
 723		len += scnprintf(buf + len, size - len, "%s%s", prefix,
 724				 zfcp_fsf_fc_security_mnemonics[i].name);
 725		prefix = ", ";
 726		fc_security &= ~zfcp_fsf_fc_security_mnemonics[i].mask;
 727	}
 728
 729	if (fc_security != 0)
 730		len += scnprintf(buf + len, size - len, "%s0x%08x",
 731				 prefix, fc_security);
 732
 733	return len;
 734}
 735
 736static void zfcp_fsf_dbf_adapter_fc_security(struct zfcp_adapter *adapter,
 737					     struct zfcp_fsf_req *req)
 738{
 739	if (adapter->fc_security_algorithms ==
 740	    adapter->fc_security_algorithms_old) {
 741		/* no change, no trace */
 742		return;
 743	}
 744
 745	zfcp_dbf_hba_fsf_fces("fsfcesa", req, ZFCP_DBF_INVALID_WWPN,
 746			      adapter->fc_security_algorithms_old,
 747			      adapter->fc_security_algorithms);
 748
 749	adapter->fc_security_algorithms_old = adapter->fc_security_algorithms;
 750}
 751
 752static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req)
 753{
 754	struct zfcp_adapter *adapter = req->adapter;
 755	struct fsf_qtcb_bottom_port *bottom = &req->qtcb->bottom.port;
 756
 757	if (req->data)
 758		memcpy(req->data, bottom, sizeof(*bottom));
 759
 760	if (adapter->adapter_features & FSF_FEATURE_FC_SECURITY)
 761		adapter->fc_security_algorithms =
 762			bottom->fc_security_algorithms;
 763	else
 764		adapter->fc_security_algorithms = 0;
 765	zfcp_fsf_dbf_adapter_fc_security(adapter, req);
 766}
 767
 768static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
 769{
 770	struct zfcp_diag_header *const diag_hdr =
 771		&req->adapter->diagnostics->port_data.header;
 772	struct fsf_qtcb *qtcb = req->qtcb;
 773	struct fsf_qtcb_bottom_port *bottom = &qtcb->bottom.port;
 774
 775	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
 776		return;
 777
 778	switch (qtcb->header.fsf_status) {
 779	case FSF_GOOD:
 780		/*
 781		 * usually we wait with an update till the cache is too old,
 782		 * but because we have the data available, update it anyway
 783		 */
 784		zfcp_diag_update_xdata(diag_hdr, bottom, false);
 785
 786		zfcp_scsi_shost_update_port_data(req->adapter, bottom);
 787		zfcp_fsf_exchange_port_evaluate(req);
 788		break;
 789	case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
 790		zfcp_diag_update_xdata(diag_hdr, bottom, true);
 791		req->status |= ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE;
 792
 793		zfcp_fsf_link_down_info_eval(req,
 794			&qtcb->header.fsf_status_qual.link_down_info);
 795
 796		zfcp_scsi_shost_update_port_data(req->adapter, bottom);
 797		zfcp_fsf_exchange_port_evaluate(req);
 798		break;
 799	}
 800}
 801
 802static struct zfcp_fsf_req *zfcp_fsf_alloc(mempool_t *pool)
 803{
 804	struct zfcp_fsf_req *req;
 805
 806	if (likely(pool))
 807		req = mempool_alloc(pool, GFP_ATOMIC);
 808	else
 809		req = kmalloc(sizeof(*req), GFP_ATOMIC);
 810
 811	if (unlikely(!req))
 812		return NULL;
 813
 814	memset(req, 0, sizeof(*req));
 815	req->pool = pool;
 816	return req;
 817}
 818
 819static struct fsf_qtcb *zfcp_fsf_qtcb_alloc(mempool_t *pool)
 820{
 821	struct fsf_qtcb *qtcb;
 822
 823	if (likely(pool))
 824		qtcb = mempool_alloc(pool, GFP_ATOMIC);
 825	else
 826		qtcb = kmem_cache_alloc(zfcp_fsf_qtcb_cache, GFP_ATOMIC);
 827
 828	if (unlikely(!qtcb))
 829		return NULL;
 830
 831	memset(qtcb, 0, sizeof(*qtcb));
 832	return qtcb;
 833}
 834
 835static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
 836						u32 fsf_cmd, u8 sbtype,
 837						mempool_t *pool)
 838{
 839	struct zfcp_adapter *adapter = qdio->adapter;
 840	struct zfcp_fsf_req *req = zfcp_fsf_alloc(pool);
 841
 842	if (unlikely(!req))
 843		return ERR_PTR(-ENOMEM);
 844
 845	if (adapter->req_no == 0)
 846		adapter->req_no++;
 847
 848	timer_setup(&req->timer, NULL, 0);
 849	init_completion(&req->completion);
 850
 851	req->adapter = adapter;
 852	req->req_id = adapter->req_no;
 853
 854	if (likely(fsf_cmd != FSF_QTCB_UNSOLICITED_STATUS)) {
 855		if (likely(pool))
 856			req->qtcb = zfcp_fsf_qtcb_alloc(
 857				adapter->pool.qtcb_pool);
 858		else
 859			req->qtcb = zfcp_fsf_qtcb_alloc(NULL);
 860
 861		if (unlikely(!req->qtcb)) {
 862			zfcp_fsf_req_free(req);
 863			return ERR_PTR(-ENOMEM);
 864		}
 865
 866		req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
 867		req->qtcb->prefix.req_id = req->req_id;
 868		req->qtcb->prefix.ulp_info = 26;
 869		req->qtcb->prefix.qtcb_type = fsf_qtcb_type[fsf_cmd];
 870		req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION;
 871		req->qtcb->header.req_handle = req->req_id;
 872		req->qtcb->header.fsf_command = fsf_cmd;
 873	}
 874
 875	zfcp_qdio_req_init(adapter->qdio, &req->qdio_req, req->req_id, sbtype,
 876			   req->qtcb, sizeof(struct fsf_qtcb));
 877
 878	return req;
 879}
 880
 881static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
 882{
 883	const bool is_srb = zfcp_fsf_req_is_status_read_buffer(req);
 884	struct zfcp_adapter *adapter = req->adapter;
 885	struct zfcp_qdio *qdio = adapter->qdio;
 886	u64 req_id = req->req_id;
 887
 888	zfcp_reqlist_add(adapter->req_list, req);
 889
 890	req->qdio_req.qdio_outb_usage = atomic_read(&qdio->req_q_free);
 891	req->issued = get_tod_clock();
 892	if (zfcp_qdio_send(qdio, &req->qdio_req)) {
 893		timer_delete_sync(&req->timer);
 894
 895		/* lookup request again, list might have changed */
 896		if (zfcp_reqlist_find_rm(adapter->req_list, req_id) == NULL)
 897			zfcp_dbf_hba_fsf_reqid("fsrsrmf", 1, adapter, req_id);
 898
 899		zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1");
 900		return -EIO;
 901	}
 902
 903	/*
 904	 * NOTE: DO NOT TOUCH ASYNC req PAST THIS POINT.
 905	 *	 ONLY TOUCH SYNC req AGAIN ON req->completion.
 906	 *
 907	 * The request might complete and be freed concurrently at any point
 908	 * now. This is not protected by the QDIO-lock (req_q_lock). So any
 909	 * uncontrolled access after this might result in an use-after-free bug.
 910	 * Only if the request doesn't have ZFCP_STATUS_FSFREQ_CLEANUP set, and
 911	 * when it is completed via req->completion, is it safe to use req
 912	 * again.
 913	 */
 914
 915	/* Don't increase for unsolicited status */
 916	if (!is_srb)
 917		adapter->fsf_req_seq_no++;
 918	adapter->req_no++;
 919
 920	return 0;
 921}
 922
 923/**
 924 * zfcp_fsf_status_read - send status read request
 925 * @qdio: pointer to struct zfcp_qdio
 926 * Returns: 0 on success, ERROR otherwise
 927 */
 928int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
 929{
 930	struct zfcp_adapter *adapter = qdio->adapter;
 931	struct zfcp_fsf_req *req;
 932	struct fsf_status_read_buffer *sr_buf;
 933	struct page *page;
 934	int retval = -EIO;
 935
 936	spin_lock_irq(&qdio->req_q_lock);
 937	if (zfcp_qdio_sbal_get(qdio))
 938		goto out;
 939
 940	req = zfcp_fsf_req_create(qdio, FSF_QTCB_UNSOLICITED_STATUS,
 941				  SBAL_SFLAGS0_TYPE_STATUS,
 942				  adapter->pool.status_read_req);
 943	if (IS_ERR(req)) {
 944		retval = PTR_ERR(req);
 945		goto out;
 946	}
 947
 948	page = mempool_alloc(adapter->pool.sr_data, GFP_ATOMIC);
 949	if (!page) {
 950		retval = -ENOMEM;
 951		goto failed_buf;
 952	}
 953	sr_buf = page_address(page);
 954	memset(sr_buf, 0, sizeof(*sr_buf));
 955	req->data = sr_buf;
 956
 957	zfcp_qdio_fill_next(qdio, &req->qdio_req, sr_buf, sizeof(*sr_buf));
 958	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 959
 960	retval = zfcp_fsf_req_send(req);
 961	if (retval)
 962		goto failed_req_send;
 963	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
 964
 965	goto out;
 966
 967failed_req_send:
 968	req->data = NULL;
 969	mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
 970failed_buf:
 971	zfcp_dbf_hba_fsf_uss("fssr__1", req);
 972	zfcp_fsf_req_free(req);
 973out:
 974	spin_unlock_irq(&qdio->req_q_lock);
 975	return retval;
 976}
 977
 978static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
 979{
 980	struct scsi_device *sdev = req->data;
 981	struct zfcp_scsi_dev *zfcp_sdev;
 982	union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual;
 983
 984	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
 985		return;
 986
 987	zfcp_sdev = sdev_to_zfcp(sdev);
 988
 989	switch (req->qtcb->header.fsf_status) {
 990	case FSF_PORT_HANDLE_NOT_VALID:
 991		if (fsq->word[0] == fsq->word[1]) {
 992			zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0,
 993						"fsafch1");
 994			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 995		}
 996		break;
 997	case FSF_LUN_HANDLE_NOT_VALID:
 998		if (fsq->word[0] == fsq->word[1]) {
 999			zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fsafch2");
1000			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1001		}
1002		break;
1003	case FSF_FCP_COMMAND_DOES_NOT_EXIST:
1004		req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
1005		break;
1006	case FSF_PORT_BOXED:
1007		zfcp_erp_set_port_status(zfcp_sdev->port,
1008					 ZFCP_STATUS_COMMON_ACCESS_BOXED);
1009		zfcp_erp_port_reopen(zfcp_sdev->port,
1010				     ZFCP_STATUS_COMMON_ERP_FAILED, "fsafch3");
1011		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1012		break;
1013	case FSF_LUN_BOXED:
1014		zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
1015		zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
1016				    "fsafch4");
1017		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1018                break;
1019	case FSF_ADAPTER_STATUS_AVAILABLE:
1020		switch (fsq->word[0]) {
1021		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1022			zfcp_fc_test_link(zfcp_sdev->port);
1023			fallthrough;
1024		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1025			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1026			break;
1027		}
1028		break;
1029	case FSF_GOOD:
1030		req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED;
1031		break;
1032	}
1033}
1034
1035/**
1036 * zfcp_fsf_abort_fcp_cmnd - abort running SCSI command
1037 * @scmnd: The SCSI command to abort
1038 * Returns: pointer to struct zfcp_fsf_req
1039 */
1040
1041struct zfcp_fsf_req *zfcp_fsf_abort_fcp_cmnd(struct scsi_cmnd *scmnd)
1042{
1043	struct zfcp_fsf_req *req = NULL;
1044	struct scsi_device *sdev = scmnd->device;
1045	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1046	struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
1047	u64 old_req_id = (u64) scmnd->host_scribble;
1048
1049	spin_lock_irq(&qdio->req_q_lock);
1050	if (zfcp_qdio_sbal_get(qdio))
1051		goto out;
1052	req = zfcp_fsf_req_create(qdio, FSF_QTCB_ABORT_FCP_CMND,
1053				  SBAL_SFLAGS0_TYPE_READ,
1054				  qdio->adapter->pool.scsi_abort);
1055	if (IS_ERR(req)) {
1056		req = NULL;
1057		goto out;
1058	}
1059
1060	if (unlikely(!(atomic_read(&zfcp_sdev->status) &
1061		       ZFCP_STATUS_COMMON_UNBLOCKED)))
1062		goto out_error_free;
1063
1064	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1065
1066	req->data = sdev;
1067	req->handler = zfcp_fsf_abort_fcp_command_handler;
1068	req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
1069	req->qtcb->header.port_handle = zfcp_sdev->port->handle;
1070	req->qtcb->bottom.support.req_handle = old_req_id;
1071
1072	zfcp_fsf_start_timer(req, ZFCP_FSF_SCSI_ER_TIMEOUT);
1073	if (!zfcp_fsf_req_send(req)) {
1074		/* NOTE: DO NOT TOUCH req, UNTIL IT COMPLETES! */
1075		goto out;
1076	}
1077
1078out_error_free:
1079	zfcp_fsf_req_free(req);
1080	req = NULL;
1081out:
1082	spin_unlock_irq(&qdio->req_q_lock);
1083	return req;
1084}
1085
1086static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
1087{
1088	struct zfcp_adapter *adapter = req->adapter;
1089	struct zfcp_fsf_ct_els *ct = req->data;
1090	struct fsf_qtcb_header *header = &req->qtcb->header;
1091
1092	ct->status = -EINVAL;
1093
1094	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1095		goto skip_fsfstatus;
1096
1097	switch (header->fsf_status) {
1098        case FSF_GOOD:
1099		ct->status = 0;
1100		zfcp_dbf_san_res("fsscth2", req);
1101		break;
1102        case FSF_SERVICE_CLASS_NOT_SUPPORTED:
1103		zfcp_fsf_class_not_supp(req);
1104		break;
1105        case FSF_ADAPTER_STATUS_AVAILABLE:
1106                switch (header->fsf_status_qual.word[0]){
1107                case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1108                case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1109			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1110			break;
1111                }
1112                break;
1113        case FSF_PORT_BOXED:
1114		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1115		break;
1116	case FSF_PORT_HANDLE_NOT_VALID:
1117		zfcp_erp_adapter_reopen(adapter, 0, "fsscth1");
1118		fallthrough;
1119	case FSF_GENERIC_COMMAND_REJECTED:
1120	case FSF_PAYLOAD_SIZE_MISMATCH:
1121	case FSF_REQUEST_SIZE_TOO_LARGE:
1122	case FSF_RESPONSE_SIZE_TOO_LARGE:
1123	case FSF_SBAL_MISMATCH:
1124		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1125		break;
1126	}
1127
1128skip_fsfstatus:
1129	if (ct->handler)
1130		ct->handler(ct->handler_data);
1131}
1132
1133static void zfcp_fsf_setup_ct_els_unchained(struct zfcp_qdio *qdio,
1134					    struct zfcp_qdio_req *q_req,
1135					    struct scatterlist *sg_req,
1136					    struct scatterlist *sg_resp)
1137{
1138	zfcp_qdio_fill_next(qdio, q_req, sg_virt(sg_req), sg_req->length);
1139	zfcp_qdio_fill_next(qdio, q_req, sg_virt(sg_resp), sg_resp->length);
1140	zfcp_qdio_set_sbale_last(qdio, q_req);
1141}
1142
1143static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
1144				       struct scatterlist *sg_req,
1145				       struct scatterlist *sg_resp)
1146{
1147	struct zfcp_adapter *adapter = req->adapter;
1148	struct zfcp_qdio *qdio = adapter->qdio;
1149	struct fsf_qtcb *qtcb = req->qtcb;
1150	u32 feat = adapter->adapter_features;
1151
1152	if (zfcp_adapter_multi_buffer_active(adapter)) {
1153		if (zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sg_req))
1154			return -EIO;
1155		qtcb->bottom.support.req_buf_length =
1156			zfcp_qdio_real_bytes(sg_req);
1157		if (zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sg_resp))
1158			return -EIO;
1159		qtcb->bottom.support.resp_buf_length =
1160			zfcp_qdio_real_bytes(sg_resp);
1161
1162		zfcp_qdio_set_data_div(qdio, &req->qdio_req, sg_nents(sg_req));
1163		zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1164		zfcp_qdio_set_scount(qdio, &req->qdio_req);
1165		return 0;
1166	}
1167
1168	/* use single, unchained SBAL if it can hold the request */
1169	if (zfcp_qdio_sg_one_sbale(sg_req) && zfcp_qdio_sg_one_sbale(sg_resp)) {
1170		zfcp_fsf_setup_ct_els_unchained(qdio, &req->qdio_req,
1171						sg_req, sg_resp);
1172		return 0;
1173	}
1174
1175	if (!(feat & FSF_FEATURE_ELS_CT_CHAINED_SBALS))
1176		return -EOPNOTSUPP;
1177
1178	if (zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sg_req))
1179		return -EIO;
1180
1181	qtcb->bottom.support.req_buf_length = zfcp_qdio_real_bytes(sg_req);
1182
1183	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1184	zfcp_qdio_skip_to_last_sbale(qdio, &req->qdio_req);
1185
1186	if (zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sg_resp))
1187		return -EIO;
1188
1189	qtcb->bottom.support.resp_buf_length = zfcp_qdio_real_bytes(sg_resp);
1190
1191	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1192
1193	return 0;
1194}
1195
1196static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req *req,
1197				 struct scatterlist *sg_req,
1198				 struct scatterlist *sg_resp,
1199				 unsigned int timeout)
1200{
1201	int ret;
1202
1203	ret = zfcp_fsf_setup_ct_els_sbals(req, sg_req, sg_resp);
1204	if (ret)
1205		return ret;
1206
1207	/* common settings for ct/gs and els requests */
1208	if (timeout > 255)
1209		timeout = 255; /* max value accepted by hardware */
1210	req->qtcb->bottom.support.service_class = FSF_CLASS_3;
1211	req->qtcb->bottom.support.timeout = timeout;
1212	zfcp_fsf_start_timer(req, (timeout + 10) * HZ);
1213
1214	return 0;
1215}
1216
1217/**
1218 * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
1219 * @wka_port: pointer to zfcp WKA port to send CT/GS to
1220 * @ct: pointer to struct zfcp_fsf_ct_els with data for CT request
1221 * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
1222 * @timeout: timeout that hardware should use, and a later software timeout
1223 */
1224int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
1225		     struct zfcp_fsf_ct_els *ct, mempool_t *pool,
1226		     unsigned int timeout)
1227{
1228	struct zfcp_qdio *qdio = wka_port->adapter->qdio;
1229	struct zfcp_fsf_req *req;
1230	int ret = -EIO;
1231
1232	spin_lock_irq(&qdio->req_q_lock);
1233	if (zfcp_qdio_sbal_get(qdio))
1234		goto out;
1235
1236	req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_GENERIC,
1237				  SBAL_SFLAGS0_TYPE_WRITE_READ, pool);
1238
1239	if (IS_ERR(req)) {
1240		ret = PTR_ERR(req);
1241		goto out;
1242	}
1243
1244	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1245	ret = zfcp_fsf_setup_ct_els(req, ct->req, ct->resp, timeout);
1246	if (ret)
1247		goto failed_send;
1248
1249	req->handler = zfcp_fsf_send_ct_handler;
1250	req->qtcb->header.port_handle = wka_port->handle;
1251	ct->d_id = wka_port->d_id;
1252	req->data = ct;
1253
1254	zfcp_dbf_san_req("fssct_1", req, wka_port->d_id);
1255
1256	ret = zfcp_fsf_req_send(req);
1257	if (ret)
1258		goto failed_send;
1259	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
1260
1261	goto out;
1262
1263failed_send:
1264	zfcp_fsf_req_free(req);
1265out:
1266	spin_unlock_irq(&qdio->req_q_lock);
1267	return ret;
1268}
1269
1270static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
1271{
1272	struct zfcp_fsf_ct_els *send_els = req->data;
1273	struct fsf_qtcb_header *header = &req->qtcb->header;
1274
1275	send_els->status = -EINVAL;
1276
1277	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1278		goto skip_fsfstatus;
1279
1280	switch (header->fsf_status) {
1281	case FSF_GOOD:
1282		send_els->status = 0;
1283		zfcp_dbf_san_res("fsselh1", req);
1284		break;
1285	case FSF_SERVICE_CLASS_NOT_SUPPORTED:
1286		zfcp_fsf_class_not_supp(req);
1287		break;
1288	case FSF_ADAPTER_STATUS_AVAILABLE:
1289		switch (header->fsf_status_qual.word[0]){
1290		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1291		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1292		case FSF_SQ_RETRY_IF_POSSIBLE:
1293			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1294			break;
1295		}
1296		break;
1297	case FSF_ELS_COMMAND_REJECTED:
1298	case FSF_PAYLOAD_SIZE_MISMATCH:
1299	case FSF_REQUEST_SIZE_TOO_LARGE:
1300	case FSF_RESPONSE_SIZE_TOO_LARGE:
1301		break;
1302	case FSF_SBAL_MISMATCH:
1303		/* should never occur, avoided in zfcp_fsf_send_els */
1304		fallthrough;
1305	default:
1306		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1307		break;
1308	}
1309skip_fsfstatus:
1310	if (send_els->handler)
1311		send_els->handler(send_els->handler_data);
1312}
1313
1314/**
1315 * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
1316 * @adapter: pointer to zfcp adapter
1317 * @d_id: N_Port_ID to send ELS to
1318 * @els: pointer to struct zfcp_fsf_ct_els with data for the ELS command
1319 * @timeout: timeout that hardware should use, and a later software timeout
1320 */
1321int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
1322		      struct zfcp_fsf_ct_els *els, unsigned int timeout)
1323{
1324	struct zfcp_fsf_req *req;
1325	struct zfcp_qdio *qdio = adapter->qdio;
1326	int ret = -EIO;
1327
1328	spin_lock_irq(&qdio->req_q_lock);
1329	if (zfcp_qdio_sbal_get(qdio))
1330		goto out;
1331
1332	req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_ELS,
1333				  SBAL_SFLAGS0_TYPE_WRITE_READ, NULL);
1334
1335	if (IS_ERR(req)) {
1336		ret = PTR_ERR(req);
1337		goto out;
1338	}
1339
1340	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1341
1342	if (!zfcp_adapter_multi_buffer_active(adapter))
1343		zfcp_qdio_sbal_limit(qdio, &req->qdio_req, 2);
1344
1345	ret = zfcp_fsf_setup_ct_els(req, els->req, els->resp, timeout);
1346
1347	if (ret)
1348		goto failed_send;
1349
1350	hton24(req->qtcb->bottom.support.d_id, d_id);
1351	req->handler = zfcp_fsf_send_els_handler;
1352	els->d_id = d_id;
1353	req->data = els;
1354
1355	zfcp_dbf_san_req("fssels1", req, d_id);
1356
1357	ret = zfcp_fsf_req_send(req);
1358	if (ret)
1359		goto failed_send;
1360	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
1361
1362	goto out;
1363
1364failed_send:
1365	zfcp_fsf_req_free(req);
1366out:
1367	spin_unlock_irq(&qdio->req_q_lock);
1368	return ret;
1369}
1370
1371int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
1372{
1373	struct zfcp_fsf_req *req;
1374	struct zfcp_qdio *qdio = erp_action->adapter->qdio;
1375	int retval = -EIO;
1376
1377	spin_lock_irq(&qdio->req_q_lock);
1378	if (zfcp_qdio_sbal_get(qdio))
1379		goto out;
1380
1381	req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA,
1382				  SBAL_SFLAGS0_TYPE_READ,
1383				  qdio->adapter->pool.erp_req);
1384
1385	if (IS_ERR(req)) {
1386		retval = PTR_ERR(req);
1387		goto out;
1388	}
1389
1390	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1391	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1392
1393	req->qtcb->bottom.config.feature_selection =
1394			FSF_FEATURE_NOTIFICATION_LOST |
1395			FSF_FEATURE_UPDATE_ALERT |
1396			FSF_FEATURE_REQUEST_SFP_DATA |
1397			FSF_FEATURE_FC_SECURITY;
1398	req->erp_action = erp_action;
1399	req->handler = zfcp_fsf_exchange_config_data_handler;
1400	erp_action->fsf_req_id = req->req_id;
1401
1402	zfcp_fsf_start_erp_timer(req);
1403	retval = zfcp_fsf_req_send(req);
1404	if (retval) {
1405		zfcp_fsf_req_free(req);
1406		erp_action->fsf_req_id = 0;
1407	}
1408	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
1409out:
1410	spin_unlock_irq(&qdio->req_q_lock);
1411	return retval;
1412}
1413
1414
1415/**
1416 * zfcp_fsf_exchange_config_data_sync() - Request information about FCP channel.
1417 * @qdio: pointer to the QDIO-Queue to use for sending the command.
1418 * @data: pointer to the QTCB-Bottom for storing the result of the command,
1419 *	  might be %NULL.
1420 *
1421 * Returns:
1422 * * 0		- Exchange Config Data was successful, @data is complete
1423 * * -EIO	- Exchange Config Data was not successful, @data is invalid
1424 * * -EAGAIN	- @data contains incomplete data
1425 * * -ENOMEM	- Some memory allocation failed along the way
1426 */
1427int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio,
1428				       struct fsf_qtcb_bottom_config *data)
1429{
1430	struct zfcp_fsf_req *req = NULL;
1431	int retval = -EIO;
1432
1433	spin_lock_irq(&qdio->req_q_lock);
1434	if (zfcp_qdio_sbal_get(qdio))
1435		goto out_unlock;
1436
1437	req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA,
1438				  SBAL_SFLAGS0_TYPE_READ, NULL);
1439
1440	if (IS_ERR(req)) {
1441		retval = PTR_ERR(req);
1442		goto out_unlock;
1443	}
1444
1445	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1446	req->handler = zfcp_fsf_exchange_config_data_handler;
1447
1448	req->qtcb->bottom.config.feature_selection =
1449			FSF_FEATURE_NOTIFICATION_LOST |
1450			FSF_FEATURE_UPDATE_ALERT |
1451			FSF_FEATURE_REQUEST_SFP_DATA |
1452			FSF_FEATURE_FC_SECURITY;
1453
1454	if (data)
1455		req->data = data;
1456
1457	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1458	retval = zfcp_fsf_req_send(req);
1459	spin_unlock_irq(&qdio->req_q_lock);
1460
1461	if (!retval) {
1462		/* NOTE: ONLY TOUCH SYNC req AGAIN ON req->completion. */
1463		wait_for_completion(&req->completion);
1464
1465		if (req->status &
1466		    (ZFCP_STATUS_FSFREQ_ERROR | ZFCP_STATUS_FSFREQ_DISMISSED))
1467			retval = -EIO;
1468		else if (req->status & ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE)
1469			retval = -EAGAIN;
1470	}
1471
1472	zfcp_fsf_req_free(req);
1473	return retval;
1474
1475out_unlock:
1476	spin_unlock_irq(&qdio->req_q_lock);
1477	return retval;
1478}
1479
1480/**
1481 * zfcp_fsf_exchange_port_data - request information about local port
1482 * @erp_action: ERP action for the adapter for which port data is requested
1483 * Returns: 0 on success, error otherwise
1484 */
1485int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
1486{
1487	struct zfcp_qdio *qdio = erp_action->adapter->qdio;
1488	struct zfcp_fsf_req *req;
1489	int retval = -EIO;
1490
1491	if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1492		return -EOPNOTSUPP;
1493
1494	spin_lock_irq(&qdio->req_q_lock);
1495	if (zfcp_qdio_sbal_get(qdio))
1496		goto out;
1497
1498	req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA,
1499				  SBAL_SFLAGS0_TYPE_READ,
1500				  qdio->adapter->pool.erp_req);
1501
1502	if (IS_ERR(req)) {
1503		retval = PTR_ERR(req);
1504		goto out;
1505	}
1506
1507	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1508	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1509
1510	req->handler = zfcp_fsf_exchange_port_data_handler;
1511	req->erp_action = erp_action;
1512	erp_action->fsf_req_id = req->req_id;
1513
1514	zfcp_fsf_start_erp_timer(req);
1515	retval = zfcp_fsf_req_send(req);
1516	if (retval) {
1517		zfcp_fsf_req_free(req);
1518		erp_action->fsf_req_id = 0;
1519	}
1520	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
1521out:
1522	spin_unlock_irq(&qdio->req_q_lock);
1523	return retval;
1524}
1525
1526/**
1527 * zfcp_fsf_exchange_port_data_sync() - Request information about local port.
1528 * @qdio: pointer to the QDIO-Queue to use for sending the command.
1529 * @data: pointer to the QTCB-Bottom for storing the result of the command,
1530 *	  might be %NULL.
1531 *
1532 * Returns:
1533 * * 0		- Exchange Port Data was successful, @data is complete
1534 * * -EIO	- Exchange Port Data was not successful, @data is invalid
1535 * * -EAGAIN	- @data contains incomplete data
1536 * * -ENOMEM	- Some memory allocation failed along the way
1537 * * -EOPNOTSUPP	- This operation is not supported
1538 */
1539int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio,
1540				     struct fsf_qtcb_bottom_port *data)
1541{
1542	struct zfcp_fsf_req *req = NULL;
1543	int retval = -EIO;
1544
1545	if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1546		return -EOPNOTSUPP;
1547
1548	spin_lock_irq(&qdio->req_q_lock);
1549	if (zfcp_qdio_sbal_get(qdio))
1550		goto out_unlock;
1551
1552	req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA,
1553				  SBAL_SFLAGS0_TYPE_READ, NULL);
1554
1555	if (IS_ERR(req)) {
1556		retval = PTR_ERR(req);
1557		goto out_unlock;
1558	}
1559
1560	if (data)
1561		req->data = data;
1562
1563	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1564
1565	req->handler = zfcp_fsf_exchange_port_data_handler;
1566	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1567	retval = zfcp_fsf_req_send(req);
1568	spin_unlock_irq(&qdio->req_q_lock);
1569
1570	if (!retval) {
1571		/* NOTE: ONLY TOUCH SYNC req AGAIN ON req->completion. */
1572		wait_for_completion(&req->completion);
1573
1574		if (req->status &
1575		    (ZFCP_STATUS_FSFREQ_ERROR | ZFCP_STATUS_FSFREQ_DISMISSED))
1576			retval = -EIO;
1577		else if (req->status & ZFCP_STATUS_FSFREQ_XDATAINCOMPLETE)
1578			retval = -EAGAIN;
1579	}
1580
1581	zfcp_fsf_req_free(req);
1582	return retval;
1583
1584out_unlock:
1585	spin_unlock_irq(&qdio->req_q_lock);
1586	return retval;
1587}
1588
1589static void zfcp_fsf_log_port_fc_security(struct zfcp_port *port,
1590					  struct zfcp_fsf_req *req)
1591{
1592	char mnemonic_old[ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH];
1593	char mnemonic_new[ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH];
1594
1595	if (port->connection_info == port->connection_info_old) {
1596		/* no change, no log nor trace */
1597		return;
1598	}
1599
1600	zfcp_dbf_hba_fsf_fces("fsfcesp", req, port->wwpn,
1601			      port->connection_info_old,
1602			      port->connection_info);
1603
1604	zfcp_fsf_scnprint_fc_security(mnemonic_old, sizeof(mnemonic_old),
1605				      port->connection_info_old,
1606				      ZFCP_FSF_PRINT_FMT_SINGLEITEM);
1607	zfcp_fsf_scnprint_fc_security(mnemonic_new, sizeof(mnemonic_new),
1608				      port->connection_info,
1609				      ZFCP_FSF_PRINT_FMT_SINGLEITEM);
1610
1611	if (strncmp(mnemonic_old, mnemonic_new,
1612		    ZFCP_FSF_MAX_FC_SECURITY_MNEMONIC_LENGTH) == 0) {
1613		/* no change in string representation, no log */
1614		goto out;
1615	}
1616
1617	if (port->connection_info_old == 0) {
1618		/* activation */
1619		dev_info(&port->adapter->ccw_device->dev,
1620			 "FC Endpoint Security of connection to remote port 0x%16llx enabled: %s\n",
1621			 port->wwpn, mnemonic_new);
1622	} else if (port->connection_info == 0) {
1623		/* deactivation */
1624		dev_warn(&port->adapter->ccw_device->dev,
1625			 "FC Endpoint Security of connection to remote port 0x%16llx disabled: was %s\n",
1626			 port->wwpn, mnemonic_old);
1627	} else {
1628		/* change */
1629		dev_warn(&port->adapter->ccw_device->dev,
1630			 "FC Endpoint Security of connection to remote port 0x%16llx changed: from %s to %s\n",
1631			 port->wwpn, mnemonic_old, mnemonic_new);
1632	}
1633
1634out:
1635	port->connection_info_old = port->connection_info;
1636}
1637
1638static void zfcp_fsf_log_security_error(const struct device *dev, u32 fsf_sqw0,
1639					u64 wwpn)
1640{
1641	switch (fsf_sqw0) {
1642
1643	/*
1644	 * Open Port command error codes
1645	 */
1646
1647	case FSF_SQ_SECURITY_REQUIRED:
1648		dev_warn_ratelimited(dev,
1649				     "FC Endpoint Security error: FC security is required but not supported or configured on remote port 0x%016llx\n",
1650				     wwpn);
1651		break;
1652	case FSF_SQ_SECURITY_TIMEOUT:
1653		dev_warn_ratelimited(dev,
1654				     "FC Endpoint Security error: a timeout prevented opening remote port 0x%016llx\n",
1655				     wwpn);
1656		break;
1657	case FSF_SQ_SECURITY_KM_UNAVAILABLE:
1658		dev_warn_ratelimited(dev,
1659				     "FC Endpoint Security error: opening remote port 0x%016llx failed because local and external key manager cannot communicate\n",
1660				     wwpn);
1661		break;
1662	case FSF_SQ_SECURITY_RKM_UNAVAILABLE:
1663		dev_warn_ratelimited(dev,
1664				     "FC Endpoint Security error: opening remote port 0x%016llx failed because it cannot communicate with the external key manager\n",
1665				     wwpn);
1666		break;
1667	case FSF_SQ_SECURITY_AUTH_FAILURE:
1668		dev_warn_ratelimited(dev,
1669				     "FC Endpoint Security error: the device could not verify the identity of remote port 0x%016llx\n",
1670				     wwpn);
1671		break;
1672
1673	/*
1674	 * Send FCP command error codes
1675	 */
1676
1677	case FSF_SQ_SECURITY_ENC_FAILURE:
1678		dev_warn_ratelimited(dev,
1679				     "FC Endpoint Security error: FC connection to remote port 0x%016llx closed because encryption broke down\n",
1680				     wwpn);
1681		break;
1682
1683	/*
1684	 * Unknown error codes
1685	 */
1686
1687	default:
1688		dev_warn_ratelimited(dev,
1689				     "FC Endpoint Security error: the device issued an unknown error code 0x%08x related to the FC connection to remote port 0x%016llx\n",
1690				     fsf_sqw0, wwpn);
1691	}
1692}
1693
1694static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
1695{
1696	struct zfcp_adapter *adapter = req->adapter;
1697	struct zfcp_port *port = req->data;
1698	struct fsf_qtcb_header *header = &req->qtcb->header;
1699	struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
1700	struct fc_els_flogi *plogi;
1701
1702	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1703		goto out;
1704
1705	switch (header->fsf_status) {
1706	case FSF_PORT_ALREADY_OPEN:
1707		break;
1708	case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
1709		dev_warn(&adapter->ccw_device->dev,
1710			 "Not enough FCP adapter resources to open "
1711			 "remote port 0x%016Lx\n",
1712			 (unsigned long long)port->wwpn);
1713		zfcp_erp_set_port_status(port,
1714					 ZFCP_STATUS_COMMON_ERP_FAILED);
1715		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1716		break;
1717	case FSF_SECURITY_ERROR:
1718		zfcp_fsf_log_security_error(&req->adapter->ccw_device->dev,
1719					    header->fsf_status_qual.word[0],
1720					    port->wwpn);
1721		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1722		break;
1723	case FSF_ADAPTER_STATUS_AVAILABLE:
1724		switch (header->fsf_status_qual.word[0]) {
1725		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1726			/* no zfcp_fc_test_link() with failed open port */
1727			fallthrough;
1728		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1729		case FSF_SQ_NO_RETRY_POSSIBLE:
1730			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1731			break;
1732		}
1733		break;
1734	case FSF_GOOD:
1735		port->handle = header->port_handle;
1736		if (adapter->adapter_features & FSF_FEATURE_FC_SECURITY)
1737			port->connection_info = bottom->connection_info;
1738		else
1739			port->connection_info = 0;
1740		zfcp_fsf_log_port_fc_security(port, req);
1741		atomic_or(ZFCP_STATUS_COMMON_OPEN |
1742				ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1743		atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_BOXED,
1744		                  &port->status);
1745		/* check whether D_ID has changed during open */
1746		/*
1747		 * FIXME: This check is not airtight, as the FCP channel does
1748		 * not monitor closures of target port connections caused on
1749		 * the remote side. Thus, they might miss out on invalidating
1750		 * locally cached WWPNs (and other N_Port parameters) of gone
1751		 * target ports. So, our heroic attempt to make things safe
1752		 * could be undermined by 'open port' response data tagged with
1753		 * obsolete WWPNs. Another reason to monitor potential
1754		 * connection closures ourself at least (by interpreting
1755		 * incoming ELS' and unsolicited status). It just crosses my
1756		 * mind that one should be able to cross-check by means of
1757		 * another GID_PN straight after a port has been opened.
1758		 * Alternately, an ADISC/PDISC ELS should suffice, as well.
1759		 */
1760		plogi = (struct fc_els_flogi *) bottom->els;
1761		if (bottom->els1_length >= FSF_PLOGI_MIN_LEN)
1762			zfcp_fc_plogi_evaluate(port, plogi);
1763		break;
1764	case FSF_UNKNOWN_OP_SUBTYPE:
1765		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1766		break;
1767	}
1768
1769out:
1770	put_device(&port->dev);
1771}
1772
1773/**
1774 * zfcp_fsf_open_port - create and send open port request
1775 * @erp_action: pointer to struct zfcp_erp_action
1776 * Returns: 0 on success, error otherwise
1777 */
1778int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
1779{
1780	struct zfcp_qdio *qdio = erp_action->adapter->qdio;
1781	struct zfcp_port *port = erp_action->port;
1782	struct zfcp_fsf_req *req;
1783	int retval = -EIO;
1784
1785	spin_lock_irq(&qdio->req_q_lock);
1786	if (zfcp_qdio_sbal_get(qdio))
1787		goto out;
1788
1789	req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID,
1790				  SBAL_SFLAGS0_TYPE_READ,
1791				  qdio->adapter->pool.erp_req);
1792
1793	if (IS_ERR(req)) {
1794		retval = PTR_ERR(req);
1795		goto out;
1796	}
1797
1798	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1799	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1800
1801	req->handler = zfcp_fsf_open_port_handler;
1802	hton24(req->qtcb->bottom.support.d_id, port->d_id);
1803	req->data = port;
1804	req->erp_action = erp_action;
1805	erp_action->fsf_req_id = req->req_id;
1806	get_device(&port->dev);
1807
1808	zfcp_fsf_start_erp_timer(req);
1809	retval = zfcp_fsf_req_send(req);
1810	if (retval) {
1811		zfcp_fsf_req_free(req);
1812		erp_action->fsf_req_id = 0;
1813		put_device(&port->dev);
1814	}
1815	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
1816out:
1817	spin_unlock_irq(&qdio->req_q_lock);
1818	return retval;
1819}
1820
1821static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
1822{
1823	struct zfcp_port *port = req->data;
1824
1825	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1826		return;
1827
1828	switch (req->qtcb->header.fsf_status) {
1829	case FSF_PORT_HANDLE_NOT_VALID:
1830		zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1");
1831		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1832		break;
1833	case FSF_ADAPTER_STATUS_AVAILABLE:
1834		break;
1835	case FSF_GOOD:
1836		zfcp_erp_clear_port_status(port, ZFCP_STATUS_COMMON_OPEN);
1837		break;
1838	}
1839}
1840
1841/**
1842 * zfcp_fsf_close_port - create and send close port request
1843 * @erp_action: pointer to struct zfcp_erp_action
1844 * Returns: 0 on success, error otherwise
1845 */
1846int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
1847{
1848	struct zfcp_qdio *qdio = erp_action->adapter->qdio;
1849	struct zfcp_fsf_req *req;
1850	int retval = -EIO;
1851
1852	spin_lock_irq(&qdio->req_q_lock);
1853	if (zfcp_qdio_sbal_get(qdio))
1854		goto out;
1855
1856	req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT,
1857				  SBAL_SFLAGS0_TYPE_READ,
1858				  qdio->adapter->pool.erp_req);
1859
1860	if (IS_ERR(req)) {
1861		retval = PTR_ERR(req);
1862		goto out;
1863	}
1864
1865	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1866	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1867
1868	req->handler = zfcp_fsf_close_port_handler;
1869	req->data = erp_action->port;
1870	req->erp_action = erp_action;
1871	req->qtcb->header.port_handle = erp_action->port->handle;
1872	erp_action->fsf_req_id = req->req_id;
1873
1874	zfcp_fsf_start_erp_timer(req);
1875	retval = zfcp_fsf_req_send(req);
1876	if (retval) {
1877		zfcp_fsf_req_free(req);
1878		erp_action->fsf_req_id = 0;
1879	}
1880	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
1881out:
1882	spin_unlock_irq(&qdio->req_q_lock);
1883	return retval;
1884}
1885
1886static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
1887{
1888	struct zfcp_fc_wka_port *wka_port = req->data;
1889	struct fsf_qtcb_header *header = &req->qtcb->header;
1890
1891	if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
1892		wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
1893		goto out;
1894	}
1895
1896	switch (header->fsf_status) {
1897	case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
1898		dev_warn(&req->adapter->ccw_device->dev,
1899			 "Opening WKA port 0x%x failed\n", wka_port->d_id);
1900		fallthrough;
1901	case FSF_ADAPTER_STATUS_AVAILABLE:
1902		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1903		wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
1904		break;
1905	case FSF_GOOD:
1906		wka_port->handle = header->port_handle;
1907		fallthrough;
1908	case FSF_PORT_ALREADY_OPEN:
1909		wka_port->status = ZFCP_FC_WKA_PORT_ONLINE;
1910	}
1911out:
1912	wake_up(&wka_port->opened);
1913}
1914
1915/**
1916 * zfcp_fsf_open_wka_port - create and send open wka-port request
1917 * @wka_port: pointer to struct zfcp_fc_wka_port
1918 * Returns: 0 on success, error otherwise
1919 */
1920int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *wka_port)
1921{
1922	struct zfcp_qdio *qdio = wka_port->adapter->qdio;
1923	struct zfcp_fsf_req *req;
1924	u64 req_id = 0;
1925	int retval = -EIO;
1926
1927	spin_lock_irq(&qdio->req_q_lock);
1928	if (zfcp_qdio_sbal_get(qdio))
1929		goto out;
1930
1931	req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID,
1932				  SBAL_SFLAGS0_TYPE_READ,
1933				  qdio->adapter->pool.erp_req);
1934
1935	if (IS_ERR(req)) {
1936		retval = PTR_ERR(req);
1937		goto out;
1938	}
1939
1940	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1941	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1942
1943	req->handler = zfcp_fsf_open_wka_port_handler;
1944	hton24(req->qtcb->bottom.support.d_id, wka_port->d_id);
1945	req->data = wka_port;
1946
1947	req_id = req->req_id;
1948
1949	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1950	retval = zfcp_fsf_req_send(req);
1951	if (retval)
1952		zfcp_fsf_req_free(req);
1953	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
1954out:
1955	spin_unlock_irq(&qdio->req_q_lock);
1956	if (!retval)
1957		zfcp_dbf_rec_run_wka("fsowp_1", wka_port, req_id);
1958	return retval;
1959}
1960
1961static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
1962{
1963	struct zfcp_fc_wka_port *wka_port = req->data;
1964
1965	if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
1966		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1967		zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1");
1968	}
1969
1970	wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
1971	wake_up(&wka_port->closed);
1972}
1973
1974/**
1975 * zfcp_fsf_close_wka_port - create and send close wka port request
1976 * @wka_port: WKA port to open
1977 * Returns: 0 on success, error otherwise
1978 */
1979int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *wka_port)
1980{
1981	struct zfcp_qdio *qdio = wka_port->adapter->qdio;
1982	struct zfcp_fsf_req *req;
1983	u64 req_id = 0;
1984	int retval = -EIO;
1985
1986	spin_lock_irq(&qdio->req_q_lock);
1987	if (zfcp_qdio_sbal_get(qdio))
1988		goto out;
1989
1990	req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT,
1991				  SBAL_SFLAGS0_TYPE_READ,
1992				  qdio->adapter->pool.erp_req);
1993
1994	if (IS_ERR(req)) {
1995		retval = PTR_ERR(req);
1996		goto out;
1997	}
1998
1999	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
2000	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
2001
2002	req->handler = zfcp_fsf_close_wka_port_handler;
2003	req->data = wka_port;
2004	req->qtcb->header.port_handle = wka_port->handle;
2005
2006	req_id = req->req_id;
2007
2008	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2009	retval = zfcp_fsf_req_send(req);
2010	if (retval)
2011		zfcp_fsf_req_free(req);
2012	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
2013out:
2014	spin_unlock_irq(&qdio->req_q_lock);
2015	if (!retval)
2016		zfcp_dbf_rec_run_wka("fscwp_1", wka_port, req_id);
2017	return retval;
2018}
2019
2020static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
2021{
2022	struct zfcp_port *port = req->data;
2023	struct fsf_qtcb_header *header = &req->qtcb->header;
2024	struct scsi_device *sdev;
2025
2026	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2027		return;
2028
2029	switch (header->fsf_status) {
2030	case FSF_PORT_HANDLE_NOT_VALID:
2031		zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1");
2032		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2033		break;
2034	case FSF_PORT_BOXED:
2035		/* can't use generic zfcp_erp_modify_port_status because
2036		 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
2037		atomic_andnot(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
2038		shost_for_each_device(sdev, port->adapter->scsi_host)
2039			if (sdev_to_zfcp(sdev)->port == port)
2040				atomic_andnot(ZFCP_STATUS_COMMON_OPEN,
2041						  &sdev_to_zfcp(sdev)->status);
2042		zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ACCESS_BOXED);
2043		zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
2044				     "fscpph2");
2045		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2046		break;
2047	case FSF_ADAPTER_STATUS_AVAILABLE:
2048		switch (header->fsf_status_qual.word[0]) {
2049		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
2050		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
2051			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2052			break;
2053		}
2054		break;
2055	case FSF_GOOD:
2056		/* can't use generic zfcp_erp_modify_port_status because
2057		 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
2058		 */
2059		atomic_andnot(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
2060		shost_for_each_device(sdev, port->adapter->scsi_host)
2061			if (sdev_to_zfcp(sdev)->port == port)
2062				atomic_andnot(ZFCP_STATUS_COMMON_OPEN,
2063						  &sdev_to_zfcp(sdev)->status);
2064		break;
2065	}
2066}
2067
2068/**
2069 * zfcp_fsf_close_physical_port - close physical port
2070 * @erp_action: pointer to struct zfcp_erp_action
2071 * Returns: 0 on success
2072 */
2073int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
2074{
2075	struct zfcp_qdio *qdio = erp_action->adapter->qdio;
2076	struct zfcp_fsf_req *req;
2077	int retval = -EIO;
2078
2079	spin_lock_irq(&qdio->req_q_lock);
2080	if (zfcp_qdio_sbal_get(qdio))
2081		goto out;
2082
2083	req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PHYSICAL_PORT,
2084				  SBAL_SFLAGS0_TYPE_READ,
2085				  qdio->adapter->pool.erp_req);
2086
2087	if (IS_ERR(req)) {
2088		retval = PTR_ERR(req);
2089		goto out;
2090	}
2091
2092	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
2093	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
2094
2095	req->data = erp_action->port;
2096	req->qtcb->header.port_handle = erp_action->port->handle;
2097	req->erp_action = erp_action;
2098	req->handler = zfcp_fsf_close_physical_port_handler;
2099	erp_action->fsf_req_id = req->req_id;
2100
2101	zfcp_fsf_start_erp_timer(req);
2102	retval = zfcp_fsf_req_send(req);
2103	if (retval) {
2104		zfcp_fsf_req_free(req);
2105		erp_action->fsf_req_id = 0;
2106	}
2107	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
2108out:
2109	spin_unlock_irq(&qdio->req_q_lock);
2110	return retval;
2111}
2112
2113static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
2114{
2115	struct zfcp_adapter *adapter = req->adapter;
2116	struct scsi_device *sdev = req->data;
2117	struct zfcp_scsi_dev *zfcp_sdev;
2118	struct fsf_qtcb_header *header = &req->qtcb->header;
2119	union fsf_status_qual *qual = &header->fsf_status_qual;
2120
2121	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2122		return;
2123
2124	zfcp_sdev = sdev_to_zfcp(sdev);
2125
2126	atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED |
2127			  ZFCP_STATUS_COMMON_ACCESS_BOXED,
2128			  &zfcp_sdev->status);
2129
2130	switch (header->fsf_status) {
2131
2132	case FSF_PORT_HANDLE_NOT_VALID:
2133		zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1");
2134		fallthrough;
2135	case FSF_LUN_ALREADY_OPEN:
2136		break;
2137	case FSF_PORT_BOXED:
2138		zfcp_erp_set_port_status(zfcp_sdev->port,
2139					 ZFCP_STATUS_COMMON_ACCESS_BOXED);
2140		zfcp_erp_port_reopen(zfcp_sdev->port,
2141				     ZFCP_STATUS_COMMON_ERP_FAILED, "fsouh_2");
2142		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2143		break;
2144	case FSF_LUN_SHARING_VIOLATION:
2145		if (qual->word[0])
2146			dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev,
2147				 "LUN 0x%016Lx on port 0x%016Lx is already in "
2148				 "use by CSS%d, MIF Image ID %x\n",
2149				 zfcp_scsi_dev_lun(sdev),
2150				 (unsigned long long)zfcp_sdev->port->wwpn,
2151				 qual->fsf_queue_designator.cssid,
2152				 qual->fsf_queue_designator.hla);
2153		zfcp_erp_set_lun_status(sdev,
2154					ZFCP_STATUS_COMMON_ERP_FAILED |
2155					ZFCP_STATUS_COMMON_ACCESS_DENIED);
2156		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2157		break;
2158	case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
2159		dev_warn(&adapter->ccw_device->dev,
2160			 "No handle is available for LUN "
2161			 "0x%016Lx on port 0x%016Lx\n",
2162			 (unsigned long long)zfcp_scsi_dev_lun(sdev),
2163			 (unsigned long long)zfcp_sdev->port->wwpn);
2164		zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
2165		fallthrough;
2166	case FSF_INVALID_COMMAND_OPTION:
2167		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2168		break;
2169	case FSF_ADAPTER_STATUS_AVAILABLE:
2170		switch (header->fsf_status_qual.word[0]) {
2171		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
2172			zfcp_fc_test_link(zfcp_sdev->port);
2173			fallthrough;
2174		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
2175			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2176			break;
2177		}
2178		break;
2179
2180	case FSF_GOOD:
2181		zfcp_sdev->lun_handle = header->lun_handle;
2182		atomic_or(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
2183		break;
2184	}
2185}
2186
2187/**
2188 * zfcp_fsf_open_lun - open LUN
2189 * @erp_action: pointer to struct zfcp_erp_action
2190 * Returns: 0 on success, error otherwise
2191 */
2192int zfcp_fsf_open_lun(struct zfcp_erp_action *erp_action)
2193{
2194	struct zfcp_adapter *adapter = erp_action->adapter;
2195	struct zfcp_qdio *qdio = adapter->qdio;
2196	struct zfcp_fsf_req *req;
2197	int retval = -EIO;
2198
2199	spin_lock_irq(&qdio->req_q_lock);
2200	if (zfcp_qdio_sbal_get(qdio))
2201		goto out;
2202
2203	req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_LUN,
2204				  SBAL_SFLAGS0_TYPE_READ,
2205				  adapter->pool.erp_req);
2206
2207	if (IS_ERR(req)) {
2208		retval = PTR_ERR(req);
2209		goto out;
2210	}
2211
2212	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
2213	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
2214
2215	req->qtcb->header.port_handle = erp_action->port->handle;
2216	req->qtcb->bottom.support.fcp_lun = zfcp_scsi_dev_lun(erp_action->sdev);
2217	req->handler = zfcp_fsf_open_lun_handler;
2218	req->data = erp_action->sdev;
2219	req->erp_action = erp_action;
2220	erp_action->fsf_req_id = req->req_id;
2221
2222	if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
2223		req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
2224
2225	zfcp_fsf_start_erp_timer(req);
2226	retval = zfcp_fsf_req_send(req);
2227	if (retval) {
2228		zfcp_fsf_req_free(req);
2229		erp_action->fsf_req_id = 0;
2230	}
2231	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
2232out:
2233	spin_unlock_irq(&qdio->req_q_lock);
2234	return retval;
2235}
2236
2237static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req *req)
2238{
2239	struct scsi_device *sdev = req->data;
2240	struct zfcp_scsi_dev *zfcp_sdev;
2241
2242	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2243		return;
2244
2245	zfcp_sdev = sdev_to_zfcp(sdev);
2246
2247	switch (req->qtcb->header.fsf_status) {
2248	case FSF_PORT_HANDLE_NOT_VALID:
2249		zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fscuh_1");
2250		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2251		break;
2252	case FSF_LUN_HANDLE_NOT_VALID:
2253		zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2");
2254		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2255		break;
2256	case FSF_PORT_BOXED:
2257		zfcp_erp_set_port_status(zfcp_sdev->port,
2258					 ZFCP_STATUS_COMMON_ACCESS_BOXED);
2259		zfcp_erp_port_reopen(zfcp_sdev->port,
2260				     ZFCP_STATUS_COMMON_ERP_FAILED, "fscuh_3");
2261		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2262		break;
2263	case FSF_ADAPTER_STATUS_AVAILABLE:
2264		switch (req->qtcb->header.fsf_status_qual.word[0]) {
2265		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
2266			zfcp_fc_test_link(zfcp_sdev->port);
2267			fallthrough;
2268		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
2269			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2270			break;
2271		}
2272		break;
2273	case FSF_GOOD:
2274		atomic_andnot(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
2275		break;
2276	}
2277}
2278
2279/**
2280 * zfcp_fsf_close_lun - close LUN
2281 * @erp_action: pointer to erp_action triggering the "close LUN"
2282 * Returns: 0 on success, error otherwise
2283 */
2284int zfcp_fsf_close_lun(struct zfcp_erp_action *erp_action)
2285{
2286	struct zfcp_qdio *qdio = erp_action->adapter->qdio;
2287	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
2288	struct zfcp_fsf_req *req;
2289	int retval = -EIO;
2290
2291	spin_lock_irq(&qdio->req_q_lock);
2292	if (zfcp_qdio_sbal_get(qdio))
2293		goto out;
2294
2295	req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_LUN,
2296				  SBAL_SFLAGS0_TYPE_READ,
2297				  qdio->adapter->pool.erp_req);
2298
2299	if (IS_ERR(req)) {
2300		retval = PTR_ERR(req);
2301		goto out;
2302	}
2303
2304	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
2305	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
2306
2307	req->qtcb->header.port_handle = erp_action->port->handle;
2308	req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
2309	req->handler = zfcp_fsf_close_lun_handler;
2310	req->data = erp_action->sdev;
2311	req->erp_action = erp_action;
2312	erp_action->fsf_req_id = req->req_id;
2313
2314	zfcp_fsf_start_erp_timer(req);
2315	retval = zfcp_fsf_req_send(req);
2316	if (retval) {
2317		zfcp_fsf_req_free(req);
2318		erp_action->fsf_req_id = 0;
2319	}
2320	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
2321out:
2322	spin_unlock_irq(&qdio->req_q_lock);
2323	return retval;
2324}
2325
2326static void zfcp_fsf_update_lat(struct zfcp_latency_record *lat_rec, u32 lat)
2327{
2328	lat_rec->sum += lat;
2329	lat_rec->min = min(lat_rec->min, lat);
2330	lat_rec->max = max(lat_rec->max, lat);
2331}
2332
2333static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
2334{
2335	struct fsf_qual_latency_info *lat_in;
2336	struct zfcp_latency_cont *lat = NULL;
2337	struct zfcp_scsi_dev *zfcp_sdev;
2338	struct zfcp_blk_drv_data blktrc;
2339	int ticks = req->adapter->timer_ticks;
2340
2341	lat_in = &req->qtcb->prefix.prot_status_qual.latency_info;
2342
2343	blktrc.flags = 0;
2344	blktrc.magic = ZFCP_BLK_DRV_DATA_MAGIC;
2345	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2346		blktrc.flags |= ZFCP_BLK_REQ_ERROR;
2347	blktrc.inb_usage = 0;
2348	blktrc.outb_usage = req->qdio_req.qdio_outb_usage;
2349
2350	if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA &&
2351	    !(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
2352		zfcp_sdev = sdev_to_zfcp(scsi->device);
2353		blktrc.flags |= ZFCP_BLK_LAT_VALID;
2354		blktrc.channel_lat = lat_in->channel_lat * ticks;
2355		blktrc.fabric_lat = lat_in->fabric_lat * ticks;
2356
2357		switch (req->qtcb->bottom.io.data_direction) {
2358		case FSF_DATADIR_DIF_READ_STRIP:
2359		case FSF_DATADIR_DIF_READ_CONVERT:
2360		case FSF_DATADIR_READ:
2361			lat = &zfcp_sdev->latencies.read;
2362			break;
2363		case FSF_DATADIR_DIF_WRITE_INSERT:
2364		case FSF_DATADIR_DIF_WRITE_CONVERT:
2365		case FSF_DATADIR_WRITE:
2366			lat = &zfcp_sdev->latencies.write;
2367			break;
2368		case FSF_DATADIR_CMND:
2369			lat = &zfcp_sdev->latencies.cmd;
2370			break;
2371		}
2372
2373		if (lat) {
2374			spin_lock(&zfcp_sdev->latencies.lock);
2375			zfcp_fsf_update_lat(&lat->channel, lat_in->channel_lat);
2376			zfcp_fsf_update_lat(&lat->fabric, lat_in->fabric_lat);
2377			lat->counter++;
2378			spin_unlock(&zfcp_sdev->latencies.lock);
2379		}
2380	}
2381
2382	blk_add_driver_data(scsi_cmd_to_rq(scsi), &blktrc, sizeof(blktrc));
2383}
2384
2385/**
2386 * zfcp_fsf_fcp_handler_common() - FCP response handler common to I/O and TMF.
2387 * @req: Pointer to FSF request.
2388 * @sdev: Pointer to SCSI device as request context.
2389 */
2390static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req,
2391					struct scsi_device *sdev)
2392{
2393	struct zfcp_scsi_dev *zfcp_sdev;
2394	struct fsf_qtcb_header *header = &req->qtcb->header;
2395
2396	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
2397		return;
2398
2399	zfcp_sdev = sdev_to_zfcp(sdev);
2400
2401	switch (header->fsf_status) {
2402	case FSF_HANDLE_MISMATCH:
2403	case FSF_PORT_HANDLE_NOT_VALID:
2404		zfcp_erp_adapter_reopen(req->adapter, 0, "fssfch1");
2405		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2406		break;
2407	case FSF_FCPLUN_NOT_VALID:
2408	case FSF_LUN_HANDLE_NOT_VALID:
2409		zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2");
2410		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2411		break;
2412	case FSF_SERVICE_CLASS_NOT_SUPPORTED:
2413		zfcp_fsf_class_not_supp(req);
2414		break;
2415	case FSF_DIRECTION_INDICATOR_NOT_VALID:
2416		dev_err(&req->adapter->ccw_device->dev,
2417			"Incorrect direction %d, LUN 0x%016Lx on port "
2418			"0x%016Lx closed\n",
2419			req->qtcb->bottom.io.data_direction,
2420			(unsigned long long)zfcp_scsi_dev_lun(sdev),
2421			(unsigned long long)zfcp_sdev->port->wwpn);
2422		zfcp_erp_adapter_shutdown(req->adapter, 0, "fssfch3");
2423		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2424		break;
2425	case FSF_CMND_LENGTH_NOT_VALID:
2426		dev_err(&req->adapter->ccw_device->dev,
2427			"Incorrect FCP_CMND length %d, FCP device closed\n",
2428			req->qtcb->bottom.io.fcp_cmnd_length);
2429		zfcp_erp_adapter_shutdown(req->adapter, 0, "fssfch4");
2430		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2431		break;
2432	case FSF_PORT_BOXED:
2433		zfcp_erp_set_port_status(zfcp_sdev->port,
2434					 ZFCP_STATUS_COMMON_ACCESS_BOXED);
2435		zfcp_erp_port_reopen(zfcp_sdev->port,
2436				     ZFCP_STATUS_COMMON_ERP_FAILED, "fssfch5");
2437		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2438		break;
2439	case FSF_LUN_BOXED:
2440		zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
2441		zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
2442				    "fssfch6");
2443		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2444		break;
2445	case FSF_ADAPTER_STATUS_AVAILABLE:
2446		if (header->fsf_status_qual.word[0] ==
2447		    FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
2448			zfcp_fc_test_link(zfcp_sdev->port);
2449		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2450		break;
2451	case FSF_SECURITY_ERROR:
2452		zfcp_fsf_log_security_error(&req->adapter->ccw_device->dev,
2453					    header->fsf_status_qual.word[0],
2454					    zfcp_sdev->port->wwpn);
2455		zfcp_erp_port_forced_reopen(zfcp_sdev->port, 0, "fssfch7");
2456		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2457		break;
2458	}
2459}
2460
2461static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req *req)
2462{
2463	struct scsi_cmnd *scpnt;
2464	struct fcp_resp_with_ext *fcp_rsp;
2465	unsigned long flags;
2466
2467	read_lock_irqsave(&req->adapter->abort_lock, flags);
2468
2469	scpnt = req->data;
2470	if (unlikely(!scpnt)) {
2471		read_unlock_irqrestore(&req->adapter->abort_lock, flags);
2472		return;
2473	}
2474
2475	zfcp_fsf_fcp_handler_common(req, scpnt->device);
2476
2477	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
2478		set_host_byte(scpnt, DID_TRANSPORT_DISRUPTED);
2479		goto skip_fsfstatus;
2480	}
2481
2482	switch (req->qtcb->header.fsf_status) {
2483	case FSF_INCONSISTENT_PROT_DATA:
2484	case FSF_INVALID_PROT_PARM:
2485		set_host_byte(scpnt, DID_ERROR);
2486		goto skip_fsfstatus;
2487	case FSF_BLOCK_GUARD_CHECK_FAILURE:
2488		zfcp_scsi_dif_sense_error(scpnt, 0x1);
2489		goto skip_fsfstatus;
2490	case FSF_APP_TAG_CHECK_FAILURE:
2491		zfcp_scsi_dif_sense_error(scpnt, 0x2);
2492		goto skip_fsfstatus;
2493	case FSF_REF_TAG_CHECK_FAILURE:
2494		zfcp_scsi_dif_sense_error(scpnt, 0x3);
2495		goto skip_fsfstatus;
2496	}
2497	BUILD_BUG_ON(sizeof(struct fcp_resp_with_ext) > FSF_FCP_RSP_SIZE);
2498	fcp_rsp = &req->qtcb->bottom.io.fcp_rsp.iu;
2499	zfcp_fc_eval_fcp_rsp(fcp_rsp, scpnt);
2500
2501skip_fsfstatus:
2502	zfcp_fsf_req_trace(req, scpnt);
2503	zfcp_dbf_scsi_result(scpnt, req);
2504
2505	scpnt->host_scribble = NULL;
2506	scsi_done(scpnt);
2507	/*
2508	 * We must hold this lock until scsi_done has been called.
2509	 * Otherwise we may call scsi_done after abort regarding this
2510	 * command has completed.
2511	 * Note: scsi_done must not block!
2512	 */
2513	read_unlock_irqrestore(&req->adapter->abort_lock, flags);
2514}
2515
2516static int zfcp_fsf_set_data_dir(struct scsi_cmnd *scsi_cmnd, u32 *data_dir)
2517{
2518	switch (scsi_get_prot_op(scsi_cmnd)) {
2519	case SCSI_PROT_NORMAL:
2520		switch (scsi_cmnd->sc_data_direction) {
2521		case DMA_NONE:
2522			*data_dir = FSF_DATADIR_CMND;
2523			break;
2524		case DMA_FROM_DEVICE:
2525			*data_dir = FSF_DATADIR_READ;
2526			break;
2527		case DMA_TO_DEVICE:
2528			*data_dir = FSF_DATADIR_WRITE;
2529			break;
2530		case DMA_BIDIRECTIONAL:
2531			return -EINVAL;
2532		}
2533		break;
2534
2535	case SCSI_PROT_READ_STRIP:
2536		*data_dir = FSF_DATADIR_DIF_READ_STRIP;
2537		break;
2538	case SCSI_PROT_WRITE_INSERT:
2539		*data_dir = FSF_DATADIR_DIF_WRITE_INSERT;
2540		break;
2541	case SCSI_PROT_READ_PASS:
2542		*data_dir = FSF_DATADIR_DIF_READ_CONVERT;
2543		break;
2544	case SCSI_PROT_WRITE_PASS:
2545		*data_dir = FSF_DATADIR_DIF_WRITE_CONVERT;
2546		break;
2547	default:
2548		return -EINVAL;
2549	}
2550
2551	return 0;
2552}
2553
2554/**
2555 * zfcp_fsf_fcp_cmnd - initiate an FCP command (for a SCSI command)
2556 * @scsi_cmnd: scsi command to be sent
2557 */
2558int zfcp_fsf_fcp_cmnd(struct scsi_cmnd *scsi_cmnd)
2559{
2560	struct zfcp_fsf_req *req;
2561	struct fcp_cmnd *fcp_cmnd;
2562	u8 sbtype = SBAL_SFLAGS0_TYPE_READ;
2563	int retval = -EIO;
2564	struct scsi_device *sdev = scsi_cmnd->device;
2565	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
2566	struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
2567	struct zfcp_qdio *qdio = adapter->qdio;
2568	struct fsf_qtcb_bottom_io *io;
2569	unsigned long flags;
2570
2571	if (unlikely(!(atomic_read(&zfcp_sdev->status) &
2572		       ZFCP_STATUS_COMMON_UNBLOCKED)))
2573		return -EBUSY;
2574
2575	spin_lock_irqsave(&qdio->req_q_lock, flags);
2576	if (atomic_read(&qdio->req_q_free) <= 0) {
2577		atomic_inc(&qdio->req_q_full);
2578		goto out;
2579	}
2580
2581	if (scsi_cmnd->sc_data_direction == DMA_TO_DEVICE)
2582		sbtype = SBAL_SFLAGS0_TYPE_WRITE;
2583
2584	req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND,
2585				  sbtype, adapter->pool.scsi_req);
2586
2587	if (IS_ERR(req)) {
2588		retval = PTR_ERR(req);
2589		goto out;
2590	}
2591
2592	BUILD_BUG_ON(sizeof(scsi_cmnd->host_scribble) < sizeof(req->req_id));
2593	scsi_cmnd->host_scribble = (unsigned char *) req->req_id;
2594
2595	io = &req->qtcb->bottom.io;
2596	req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
2597	req->data = scsi_cmnd;
2598	req->handler = zfcp_fsf_fcp_cmnd_handler;
2599	req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
2600	req->qtcb->header.port_handle = zfcp_sdev->port->handle;
2601	io->service_class = FSF_CLASS_3;
2602	io->fcp_cmnd_length = FCP_CMND_LEN;
2603
2604	if (scsi_get_prot_op(scsi_cmnd) != SCSI_PROT_NORMAL) {
2605		io->data_block_length = scsi_prot_interval(scsi_cmnd);
2606		io->ref_tag_value = scsi_prot_ref_tag(scsi_cmnd);
2607	}
2608
2609	if (zfcp_fsf_set_data_dir(scsi_cmnd, &io->data_direction))
2610		goto failed_scsi_cmnd;
2611
2612	BUILD_BUG_ON(sizeof(struct fcp_cmnd) > FSF_FCP_CMND_SIZE);
2613	fcp_cmnd = &req->qtcb->bottom.io.fcp_cmnd.iu;
2614	zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd);
2615
2616	if ((scsi_get_prot_op(scsi_cmnd) != SCSI_PROT_NORMAL) &&
2617	    scsi_prot_sg_count(scsi_cmnd)) {
2618		zfcp_qdio_set_data_div(qdio, &req->qdio_req,
2619				       scsi_prot_sg_count(scsi_cmnd));
2620		retval = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req,
2621						 scsi_prot_sglist(scsi_cmnd));
2622		if (retval)
2623			goto failed_scsi_cmnd;
2624		io->prot_data_length = zfcp_qdio_real_bytes(
2625						scsi_prot_sglist(scsi_cmnd));
2626	}
2627
2628	retval = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req,
2629					 scsi_sglist(scsi_cmnd));
2630	if (unlikely(retval))
2631		goto failed_scsi_cmnd;
2632
2633	zfcp_qdio_set_sbale_last(adapter->qdio, &req->qdio_req);
2634	if (zfcp_adapter_multi_buffer_active(adapter))
2635		zfcp_qdio_set_scount(qdio, &req->qdio_req);
2636
2637	retval = zfcp_fsf_req_send(req);
2638	if (unlikely(retval))
2639		goto failed_scsi_cmnd;
2640	/* NOTE: DO NOT TOUCH req PAST THIS POINT! */
2641
2642	goto out;
2643
2644failed_scsi_cmnd:
2645	zfcp_fsf_req_free(req);
2646	scsi_cmnd->host_scribble = NULL;
2647out:
2648	spin_unlock_irqrestore(&qdio->req_q_lock, flags);
2649	return retval;
2650}
2651
2652static void zfcp_fsf_fcp_task_mgmt_handler(struct zfcp_fsf_req *req)
2653{
2654	struct scsi_device *sdev = req->data;
2655	struct fcp_resp_with_ext *fcp_rsp;
2656	struct fcp_resp_rsp_info *rsp_info;
2657
2658	zfcp_fsf_fcp_handler_common(req, sdev);
2659
2660	fcp_rsp = &req->qtcb->bottom.io.fcp_rsp.iu;
2661	rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
2662
2663	if ((rsp_info->rsp_code != FCP_TMF_CMPL) ||
2664	     (req->status & ZFCP_STATUS_FSFREQ_ERROR))
2665		req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
2666}
2667
2668/**
2669 * zfcp_fsf_fcp_task_mgmt() - Send SCSI task management command (TMF).
2670 * @sdev: Pointer to SCSI device to send the task management command to.
2671 * @tm_flags: Unsigned byte for task management flags.
2672 *
2673 * Return: On success pointer to struct zfcp_fsf_req, %NULL otherwise.
2674 */
2675struct zfcp_fsf_req *zfcp_fsf_fcp_task_mgmt(struct scsi_device *sdev,
2676					    u8 tm_flags)
2677{
2678	struct zfcp_fsf_req *req = NULL;
2679	struct fcp_cmnd *fcp_cmnd;
2680	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
2681	struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
2682
2683	if (unlikely(!(atomic_read(&zfcp_sdev->status) &
2684		       ZFCP_STATUS_COMMON_UNBLOCKED)))
2685		return NULL;
2686
2687	spin_lock_irq(&qdio->req_q_lock);
2688	if (zfcp_qdio_sbal_get(qdio))
2689		goto out;
2690
2691	req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND,
2692				  SBAL_SFLAGS0_TYPE_WRITE,
2693				  qdio->adapter->pool.scsi_req);
2694
2695	if (IS_ERR(req)) {
2696		req = NULL;
2697		goto out;
2698	}
2699
2700	req->data = sdev;
2701
2702	req->handler = zfcp_fsf_fcp_task_mgmt_handler;
2703	req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
2704	req->qtcb->header.port_handle = zfcp_sdev->port->handle;
2705	req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
2706	req->qtcb->bottom.io.service_class = FSF_CLASS_3;
2707	req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN;
2708
2709	zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
2710
2711	fcp_cmnd = &req->qtcb->bottom.io.fcp_cmnd.iu;
2712	zfcp_fc_fcp_tm(fcp_cmnd, sdev, tm_flags);
2713
2714	zfcp_fsf_start_timer(req, ZFCP_FSF_SCSI_ER_TIMEOUT);
2715	if (!zfcp_fsf_req_send(req)) {
2716		/* NOTE: DO NOT TOUCH req, UNTIL IT COMPLETES! */
2717		goto out;
2718	}
2719
2720	zfcp_fsf_req_free(req);
2721	req = NULL;
2722out:
2723	spin_unlock_irq(&qdio->req_q_lock);
2724	return req;
2725}
2726
2727/**
2728 * zfcp_fsf_reqid_check - validate req_id contained in SBAL returned by QDIO
2729 * @qdio: pointer to struct zfcp_qdio
2730 * @sbal_idx: response queue index of SBAL to be processed
2731 */
2732void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
2733{
2734	struct zfcp_adapter *adapter = qdio->adapter;
2735	struct qdio_buffer *sbal = qdio->res_q[sbal_idx];
2736	struct qdio_buffer_element *sbale;
2737	struct zfcp_fsf_req *fsf_req;
2738	u64 req_id;
2739	int idx;
2740
2741	for (idx = 0; idx < QDIO_MAX_ELEMENTS_PER_BUFFER; idx++) {
2742
2743		sbale = &sbal->element[idx];
2744		req_id = dma64_to_u64(sbale->addr);
2745		fsf_req = zfcp_reqlist_find_rm(adapter->req_list, req_id);
2746
2747		if (!fsf_req) {
2748			/*
2749			 * Unknown request means that we have potentially memory
2750			 * corruption and must stop the machine immediately.
2751			 */
2752			zfcp_qdio_siosl(adapter);
2753			panic("error: unknown req_id (%llx) on adapter %s.\n",
2754			      req_id, dev_name(&adapter->ccw_device->dev));
2755		}
2756
2757		zfcp_fsf_req_complete(fsf_req);
2758
2759		if (likely(sbale->eflags & SBAL_EFLAGS_LAST_ENTRY))
2760			break;
2761	}
2762}