zfcp_fsf.c 69.4 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
C
Christof Schmitt 已提交
2
 * zfcp device driver
L
Linus Torvalds 已提交
3
 *
C
Christof Schmitt 已提交
4
 * Implementation of FSF commands.
L
Linus Torvalds 已提交
5
 *
C
Christof Schmitt 已提交
6
 * Copyright IBM Corporation 2002, 2008
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 */

#include "zfcp_ext.h"

/* association between FSF command and FSF QTCB type */
static u32 fsf_qtcb_type[] = {
	[FSF_QTCB_FCP_CMND] =             FSF_IO_COMMAND,
	[FSF_QTCB_ABORT_FCP_CMND] =       FSF_SUPPORT_COMMAND,
	[FSF_QTCB_OPEN_PORT_WITH_DID] =   FSF_SUPPORT_COMMAND,
	[FSF_QTCB_OPEN_LUN] =             FSF_SUPPORT_COMMAND,
	[FSF_QTCB_CLOSE_LUN] =            FSF_SUPPORT_COMMAND,
	[FSF_QTCB_CLOSE_PORT] =           FSF_SUPPORT_COMMAND,
	[FSF_QTCB_CLOSE_PHYSICAL_PORT] =  FSF_SUPPORT_COMMAND,
	[FSF_QTCB_SEND_ELS] =             FSF_SUPPORT_COMMAND,
	[FSF_QTCB_SEND_GENERIC] =         FSF_SUPPORT_COMMAND,
	[FSF_QTCB_EXCHANGE_CONFIG_DATA] = FSF_CONFIG_COMMAND,
	[FSF_QTCB_EXCHANGE_PORT_DATA] =   FSF_PORT_COMMAND,
	[FSF_QTCB_DOWNLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND,
	[FSF_QTCB_UPLOAD_CONTROL_FILE] =  FSF_SUPPORT_COMMAND
};

S
Swen Schillig 已提交
28
static const char *zfcp_act_subtable_type[] = {
L
Linus Torvalds 已提交
29 30 31
	"unknown", "OS", "WWPN", "DID", "LUN"
};

C
Christof Schmitt 已提交
32 33
static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
{
S
Swen Schillig 已提交
34
	u16 subtable = table >> 16;
C
Christof Schmitt 已提交
35 36
	u16 rule = table & 0xffff;

S
Swen Schillig 已提交
37
	if (subtable && subtable < ARRAY_SIZE(zfcp_act_subtable_type))
C
Christof Schmitt 已提交
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
		dev_warn(&adapter->ccw_device->dev,
			 "Access denied in subtable %s, rule %d.\n",
			 zfcp_act_subtable_type[subtable], rule);
}

static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req,
					struct zfcp_port *port)
{
	struct fsf_qtcb_header *header = &req->qtcb->header;
	dev_warn(&req->adapter->ccw_device->dev,
		 "Access denied, cannot send command to port 0x%016Lx.\n",
		 port->wwpn);
	zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
	zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
	zfcp_erp_port_access_denied(port, 55, req);
	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
}

static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req *req,
					struct zfcp_unit *unit)
{
	struct fsf_qtcb_header *header = &req->qtcb->header;
	dev_warn(&req->adapter->ccw_device->dev,
		 "Access denied for unit 0x%016Lx on port 0x%016Lx.\n",
		 unit->fcp_lun, unit->port->wwpn);
	zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
	zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
	zfcp_erp_unit_access_denied(unit, 59, req);
	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
}

static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
{
	dev_err(&req->adapter->ccw_device->dev,
		"Required FC class not supported by adapter, "
		"shutting down adapter.\n");
	zfcp_erp_adapter_shutdown(req->adapter, 0, 123, req);
	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
}

S
Swen Schillig 已提交
78 79 80
/**
 * zfcp_fsf_req_free - free memory used by fsf request
 * @fsf_req: pointer to struct zfcp_fsf_req
L
Linus Torvalds 已提交
81
 */
S
Swen Schillig 已提交
82
void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
83
{
S
Swen Schillig 已提交
84 85
	if (likely(req->pool)) {
		mempool_free(req, req->pool);
86 87 88
		return;
	}

S
Swen Schillig 已提交
89 90
	if (req->qtcb) {
		kmem_cache_free(zfcp_data.fsf_req_qtcb_cache, req);
91 92
		return;
	}
L
Linus Torvalds 已提交
93 94
}

S
Swen Schillig 已提交
95 96 97 98
/**
 * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
 * @adapter: pointer to struct zfcp_adapter
 *
99 100 101 102
 * Never ever call this without shutting down the adapter first.
 * Otherwise the adapter would continue using and corrupting s390 storage.
 * Included BUG_ON() call to ensure this is done.
 * ERP is supposed to be the only user of this function.
L
Linus Torvalds 已提交
103
 */
104
void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
105
{
S
Swen Schillig 已提交
106
	struct zfcp_fsf_req *req, *tmp;
107
	unsigned long flags;
108
	LIST_HEAD(remove_queue);
109
	unsigned int i;
110

S
Swen Schillig 已提交
111
	BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
112
	spin_lock_irqsave(&adapter->req_list_lock, flags);
113
	for (i = 0; i < REQUEST_LIST_SIZE; i++)
114
		list_splice_init(&adapter->req_list[i], &remove_queue);
115 116
	spin_unlock_irqrestore(&adapter->req_list_lock, flags);

S
Swen Schillig 已提交
117 118 119 120
	list_for_each_entry_safe(req, tmp, &remove_queue, list) {
		list_del(&req->list);
		req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
		zfcp_fsf_req_complete(req);
L
Linus Torvalds 已提交
121 122 123
	}
}

S
Swen Schillig 已提交
124
static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
125
{
S
Swen Schillig 已提交
126 127 128 129 130
	struct fsf_status_read_buffer *sr_buf = req->data;
	struct zfcp_adapter *adapter = req->adapter;
	struct zfcp_port *port;
	int d_id = sr_buf->d_id & ZFCP_DID_MASK;
	unsigned long flags;
L
Linus Torvalds 已提交
131

S
Swen Schillig 已提交
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
	read_lock_irqsave(&zfcp_data.config_lock, flags);
	list_for_each_entry(port, &adapter->port_list_head, list)
		if (port->d_id == d_id) {
			read_unlock_irqrestore(&zfcp_data.config_lock, flags);
			switch (sr_buf->status_subtype) {
			case FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT:
				zfcp_erp_port_reopen(port, 0, 101, req);
				break;
			case FSF_STATUS_READ_SUB_ERROR_PORT:
				zfcp_erp_port_shutdown(port, 0, 122, req);
				break;
			}
			return;
		}
	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
L
Linus Torvalds 已提交
147 148
}

S
Swen Schillig 已提交
149
static void zfcp_fsf_bit_error_threshold(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
150
{
S
Swen Schillig 已提交
151 152 153
	struct zfcp_adapter *adapter = req->adapter;
	struct fsf_status_read_buffer *sr_buf = req->data;
	struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
L
Linus Torvalds 已提交
154

S
Swen Schillig 已提交
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
	dev_warn(&adapter->ccw_device->dev,
		 "Warning: bit error threshold data "
		 "received for the adapter: "
		 "link failures = %i, loss of sync errors = %i, "
		 "loss of signal errors = %i, "
		 "primitive sequence errors = %i, "
		 "invalid transmission word errors = %i, "
		 "CRC errors = %i).\n",
		 err->link_failure_error_count,
		 err->loss_of_sync_error_count,
		 err->loss_of_signal_error_count,
		 err->primitive_sequence_error_count,
		 err->invalid_transmission_word_error_count,
		 err->crc_error_count);
	dev_warn(&adapter->ccw_device->dev,
		 "Additional bit error threshold data of the adapter: "
		 "primitive sequence event time-outs = %i, "
		 "elastic buffer overrun errors = %i, "
		 "advertised receive buffer-to-buffer credit = %i, "
		 "current receice buffer-to-buffer credit = %i, "
		 "advertised transmit buffer-to-buffer credit = %i, "
		 "current transmit buffer-to-buffer credit = %i).\n",
		 err->primitive_sequence_event_timeout_count,
		 err->elastic_buffer_overrun_error_count,
		 err->advertised_receive_b2b_credit,
		 err->current_receive_b2b_credit,
		 err->advertised_transmit_b2b_credit,
		 err->current_transmit_b2b_credit);
L
Linus Torvalds 已提交
183 184
}

S
Swen Schillig 已提交
185 186
static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, u8 id,
					 struct fsf_link_down_info *link_down)
187
{
S
Swen Schillig 已提交
188
	struct zfcp_adapter *adapter = req->adapter;
189

S
Swen Schillig 已提交
190
	if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
191 192 193 194
		return;

	atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);

S
Swen Schillig 已提交
195
	if (!link_down)
196
		goto out;
197

198 199
	switch (link_down->error_code) {
	case FSF_PSQ_LINK_NO_LIGHT:
S
Swen Schillig 已提交
200 201
		dev_warn(&req->adapter->ccw_device->dev,
			 "The local link is down: no light detected.\n");
202 203
		break;
	case FSF_PSQ_LINK_WRAP_PLUG:
S
Swen Schillig 已提交
204 205
		dev_warn(&req->adapter->ccw_device->dev,
			 "The local link is down: wrap plug detected.\n");
206 207
		break;
	case FSF_PSQ_LINK_NO_FCP:
S
Swen Schillig 已提交
208
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
209 210
			 "The local link is down: "
			 "adjacent node on link does not support FCP.\n");
211 212
		break;
	case FSF_PSQ_LINK_FIRMWARE_UPDATE:
S
Swen Schillig 已提交
213
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
214 215 216
			 "The local link is down: "
			 "firmware update in progress.\n");
		break;
217
	case FSF_PSQ_LINK_INVALID_WWPN:
S
Swen Schillig 已提交
218
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
219 220
			 "The local link is down: "
			 "duplicate or invalid WWPN detected.\n");
221 222
		break;
	case FSF_PSQ_LINK_NO_NPIV_SUPPORT:
S
Swen Schillig 已提交
223
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
224 225
			 "The local link is down: "
			 "no support for NPIV by Fabric.\n");
226 227
		break;
	case FSF_PSQ_LINK_NO_FCP_RESOURCES:
S
Swen Schillig 已提交
228
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
229 230
			 "The local link is down: "
			 "out of resource in FCP daughtercard.\n");
231 232
		break;
	case FSF_PSQ_LINK_NO_FABRIC_RESOURCES:
S
Swen Schillig 已提交
233
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
234 235
			 "The local link is down: "
			 "out of resource in Fabric.\n");
236 237
		break;
	case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE:
S
Swen Schillig 已提交
238
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
239 240
			 "The local link is down: "
			 "unable to login to Fabric.\n");
241 242
		break;
	case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED:
S
Swen Schillig 已提交
243
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
244
			 "WWPN assignment file corrupted on adapter.\n");
245 246
		break;
	case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED:
S
Swen Schillig 已提交
247
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
248
			 "Mode table corrupted on adapter.\n");
249 250
		break;
	case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT:
S
Swen Schillig 已提交
251
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
252
			 "No WWPN for assignment table on adapter.\n");
253 254
		break;
	default:
S
Swen Schillig 已提交
255
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
256
			 "The local link to adapter is down.\n");
257
	}
S
Swen Schillig 已提交
258 259
out:
	zfcp_erp_adapter_failed(adapter, id, req);
260 261
}

S
Swen Schillig 已提交
262
static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
263
{
S
Swen Schillig 已提交
264 265 266 267
	struct zfcp_adapter *adapter = req->adapter;
	struct fsf_status_read_buffer *sr_buf = req->data;
	struct fsf_link_down_info *ldi =
		(struct fsf_link_down_info *) &sr_buf->payload;
L
Linus Torvalds 已提交
268

S
Swen Schillig 已提交
269 270 271 272 273
	switch (sr_buf->status_subtype) {
	case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
		dev_warn(&adapter->ccw_device->dev,
			 "Physical link is down.\n");
		zfcp_fsf_link_down_info_eval(req, 38, ldi);
L
Linus Torvalds 已提交
274
		break;
S
Swen Schillig 已提交
275 276 277 278 279
	case FSF_STATUS_READ_SUB_FDISC_FAILED:
		dev_warn(&adapter->ccw_device->dev,
			 "Local link is down "
			 "due to failed FDISC login.\n");
		zfcp_fsf_link_down_info_eval(req, 39, ldi);
L
Linus Torvalds 已提交
280
		break;
S
Swen Schillig 已提交
281 282 283 284 285 286 287
	case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
		dev_warn(&adapter->ccw_device->dev,
			 "Local link is down "
			 "due to firmware update on adapter.\n");
		zfcp_fsf_link_down_info_eval(req, 40, NULL);
	};
}
L
Linus Torvalds 已提交
288

S
Swen Schillig 已提交
289 290 291 292
static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
{
	struct zfcp_adapter *adapter = req->adapter;
	struct fsf_status_read_buffer *sr_buf = req->data;
L
Linus Torvalds 已提交
293

S
Swen Schillig 已提交
294 295 296 297 298 299
	if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
		zfcp_hba_dbf_event_fsf_unsol("dism", adapter, sr_buf);
		mempool_free(sr_buf, adapter->pool.data_status_read);
		zfcp_fsf_req_free(req);
		return;
	}
L
Linus Torvalds 已提交
300

S
Swen Schillig 已提交
301
	zfcp_hba_dbf_event_fsf_unsol("read", adapter, sr_buf);
L
Linus Torvalds 已提交
302

S
Swen Schillig 已提交
303 304 305
	switch (sr_buf->status_type) {
	case FSF_STATUS_READ_PORT_CLOSED:
		zfcp_fsf_status_read_port_closed(req);
L
Linus Torvalds 已提交
306
		break;
S
Swen Schillig 已提交
307 308
	case FSF_STATUS_READ_INCOMING_ELS:
		zfcp_fc_incoming_els(req);
L
Linus Torvalds 已提交
309
		break;
S
Swen Schillig 已提交
310
	case FSF_STATUS_READ_SENSE_DATA_AVAIL:
L
Linus Torvalds 已提交
311
		break;
S
Swen Schillig 已提交
312 313
	case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
		zfcp_fsf_bit_error_threshold(req);
L
Linus Torvalds 已提交
314
		break;
S
Swen Schillig 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
	case FSF_STATUS_READ_LINK_DOWN:
		zfcp_fsf_status_read_link_down(req);
		break;
	case FSF_STATUS_READ_LINK_UP:
		dev_info(&adapter->ccw_device->dev,
			 "Local link was replugged.\n");
		/* All ports should be marked as ready to run again */
		zfcp_erp_modify_adapter_status(adapter, 30, NULL,
					       ZFCP_STATUS_COMMON_RUNNING,
					       ZFCP_SET);
		zfcp_erp_adapter_reopen(adapter,
					ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
					ZFCP_STATUS_COMMON_ERP_FAILED,
					102, req);
		break;
	case FSF_STATUS_READ_NOTIFICATION_LOST:
		if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_ACT_UPDATED)
			zfcp_erp_adapter_access_changed(adapter, 135, req);
		if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
			schedule_work(&adapter->scan_work);
		break;
	case FSF_STATUS_READ_CFDC_UPDATED:
		zfcp_erp_adapter_access_changed(adapter, 136, req);
		break;
	case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
		adapter->adapter_features = sr_buf->payload.word[0];
L
Linus Torvalds 已提交
341 342 343
		break;
	}

S
Swen Schillig 已提交
344 345
	mempool_free(sr_buf, adapter->pool.data_status_read);
	zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
346

S
Swen Schillig 已提交
347 348 349
	atomic_inc(&adapter->stat_miss);
	schedule_work(&adapter->stat_work);
}
L
Linus Torvalds 已提交
350

S
Swen Schillig 已提交
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
{
	switch (req->qtcb->header.fsf_status_qual.word[0]) {
	case FSF_SQ_FCP_RSP_AVAILABLE:
	case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
	case FSF_SQ_NO_RETRY_POSSIBLE:
	case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
		return;
	case FSF_SQ_COMMAND_ABORTED:
		req->status |= ZFCP_STATUS_FSFREQ_ABORTED;
		break;
	case FSF_SQ_NO_RECOM:
		dev_err(&req->adapter->ccw_device->dev,
			"No recommendation could be given for a "
			"problem on the adapter.\n");
		zfcp_erp_adapter_shutdown(req->adapter, 0, 121, req);
		break;
	}
	/* all non-return stats set FSFREQ_ERROR*/
	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
371 372
}

S
Swen Schillig 已提交
373
static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
374
{
S
Swen Schillig 已提交
375 376
	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
		return;
L
Linus Torvalds 已提交
377

S
Swen Schillig 已提交
378 379 380 381 382 383 384 385 386 387 388 389 390 391
	switch (req->qtcb->header.fsf_status) {
	case FSF_UNKNOWN_COMMAND:
		dev_err(&req->adapter->ccw_device->dev,
			"Command issued by the device driver (0x%x) is "
			"not known by the adapter.\n",
			req->qtcb->header.fsf_command);
		zfcp_erp_adapter_shutdown(req->adapter, 0, 120, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		zfcp_fsf_fsfstatus_qual_eval(req);
		break;
	}
}
L
Linus Torvalds 已提交
392

S
Swen Schillig 已提交
393 394 395 396 397
static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
{
	struct zfcp_adapter *adapter = req->adapter;
	struct fsf_qtcb *qtcb = req->qtcb;
	union fsf_prot_status_qual *psq = &qtcb->prefix.prot_status_qual;
L
Linus Torvalds 已提交
398

S
Swen Schillig 已提交
399
	zfcp_hba_dbf_event_fsf_response(req);
L
Linus Torvalds 已提交
400

S
Swen Schillig 已提交
401 402 403 404 405
	if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */
		return;
	}
L
Linus Torvalds 已提交
406

S
Swen Schillig 已提交
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
	switch (qtcb->prefix.prot_status) {
	case FSF_PROT_GOOD:
	case FSF_PROT_FSF_STATUS_PRESENTED:
		return;
	case FSF_PROT_QTCB_VERSION_ERROR:
		dev_err(&adapter->ccw_device->dev,
			"The QTCB version requested by zfcp (0x%x) is not "
			"supported by the FCP adapter (lowest supported "
			"0x%x, highest supported 0x%x).\n",
			FSF_QTCB_CURRENT_VERSION, psq->word[0],
			psq->word[1]);
		zfcp_erp_adapter_shutdown(adapter, 0, 117, req);
		break;
	case FSF_PROT_ERROR_STATE:
	case FSF_PROT_SEQ_NUMB_ERROR:
		zfcp_erp_adapter_reopen(adapter, 0, 98, req);
		req->status |= ZFCP_STATUS_FSFREQ_RETRY;
		break;
	case FSF_PROT_UNSUPP_QTCB_TYPE:
		dev_err(&adapter->ccw_device->dev,
			"Packet header type used by the device driver is "
			"incompatible with that used on the adapter.\n");
		zfcp_erp_adapter_shutdown(adapter, 0, 118, req);
		break;
	case FSF_PROT_HOST_CONNECTION_INITIALIZING:
		atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
				&adapter->status);
		break;
	case FSF_PROT_DUPLICATE_REQUEST_ID:
		dev_err(&adapter->ccw_device->dev,
			"The request identifier 0x%Lx is ambiguous.\n",
			(unsigned long long)qtcb->bottom.support.req_handle);
		zfcp_erp_adapter_shutdown(adapter, 0, 78, req);
		break;
	case FSF_PROT_LINK_DOWN:
		zfcp_fsf_link_down_info_eval(req, 37, &psq->link_down_info);
		/* FIXME: reopening adapter now? better wait for link up */
		zfcp_erp_adapter_reopen(adapter, 0, 79, req);
		break;
	case FSF_PROT_REEST_QUEUE:
		/* All ports should be marked as ready to run again */
		zfcp_erp_modify_adapter_status(adapter, 28, NULL,
					       ZFCP_STATUS_COMMON_RUNNING,
					       ZFCP_SET);
		zfcp_erp_adapter_reopen(adapter,
					ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
					ZFCP_STATUS_COMMON_ERP_FAILED, 99, req);
		break;
	default:
		dev_err(&adapter->ccw_device->dev,
			"Transfer protocol status information"
			"provided by the adapter (0x%x) "
			"is not compatible with the device driver.\n",
			qtcb->prefix.prot_status);
		zfcp_erp_adapter_shutdown(adapter, 0, 119, req);
	}
	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
464 465
}

S
Swen Schillig 已提交
466 467 468 469 470 471 472 473 474 475
/**
 * zfcp_fsf_req_complete - process completion of a FSF request
 * @fsf_req: The FSF request that has been completed.
 *
 * When a request has been completed either from the FCP adapter,
 * or it has been dismissed due to a queue shutdown, this function
 * is called to process the completion status and trigger further
 * events related to the FSF request.
 */
void zfcp_fsf_req_complete(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
476
{
S
Swen Schillig 已提交
477 478 479 480
	if (unlikely(req->fsf_command == FSF_QTCB_UNSOLICITED_STATUS)) {
		zfcp_fsf_status_read_handler(req);
		return;
	}
L
Linus Torvalds 已提交
481

S
Swen Schillig 已提交
482 483 484 485
	del_timer(&req->timer);
	zfcp_fsf_protstatus_eval(req);
	zfcp_fsf_fsfstatus_eval(req);
	req->handler(req);
L
Linus Torvalds 已提交
486

S
Swen Schillig 已提交
487 488 489
	if (req->erp_action)
		zfcp_erp_async_handler(req->erp_action, 0);
	req->status |= ZFCP_STATUS_FSFREQ_COMPLETED;
L
Linus Torvalds 已提交
490

S
Swen Schillig 已提交
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
	if (likely(req->status & ZFCP_STATUS_FSFREQ_CLEANUP))
		zfcp_fsf_req_free(req);
	else
	/* notify initiator waiting for the requests completion */
	/*
	 * FIXME: Race! We must not access fsf_req here as it might have been
	 * cleaned up already due to the set ZFCP_STATUS_FSFREQ_COMPLETED
	 * flag. It's an improbable case. But, we have the same paranoia for
	 * the cleanup flag already.
	 * Might better be handled using complete()?
	 * (setting the flag and doing wakeup ought to be atomic
	 *  with regard to checking the flag as long as waitqueue is
	 *  part of the to be released structure)
	 */
		wake_up(&req->completion_wq);
}
L
Linus Torvalds 已提交
507

S
Swen Schillig 已提交
508 509 510 511 512
static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
{
	struct fsf_qtcb_bottom_config *bottom;
	struct zfcp_adapter *adapter = req->adapter;
	struct Scsi_Host *shost = adapter->scsi_host;
L
Linus Torvalds 已提交
513

S
Swen Schillig 已提交
514
	bottom = &req->qtcb->bottom.config;
L
Linus Torvalds 已提交
515

S
Swen Schillig 已提交
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
	if (req->data)
		memcpy(req->data, bottom, sizeof(*bottom));

	fc_host_node_name(shost) = bottom->nport_serv_param.wwnn;
	fc_host_port_name(shost) = bottom->nport_serv_param.wwpn;
	fc_host_port_id(shost) = bottom->s_id & ZFCP_DID_MASK;
	fc_host_speed(shost) = bottom->fc_link_speed;
	fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3;

	adapter->hydra_version = bottom->adapter_type;
	adapter->timer_ticks = bottom->timer_interval;

	if (fc_host_permanent_port_name(shost) == -1)
		fc_host_permanent_port_name(shost) = fc_host_port_name(shost);

	switch (bottom->fc_topology) {
	case FSF_TOPO_P2P:
		adapter->peer_d_id = bottom->peer_d_id & ZFCP_DID_MASK;
		adapter->peer_wwpn = bottom->plogi_payload.wwpn;
		adapter->peer_wwnn = bottom->plogi_payload.wwnn;
		fc_host_port_type(shost) = FC_PORTTYPE_PTP;
		if (req->erp_action)
			dev_info(&adapter->ccw_device->dev,
				 "Point-to-Point fibrechannel "
				 "configuration detected.\n");
		break;
	case FSF_TOPO_FABRIC:
		fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
		if (req->erp_action)
			dev_info(&adapter->ccw_device->dev,
				 "Switched fabric fibrechannel "
				 "network detected.\n");
		break;
	case FSF_TOPO_AL:
		fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
		dev_err(&adapter->ccw_device->dev,
			"Unsupported arbitrated loop fibrechannel "
			"topology detected, shutting down "
			"adapter.\n");
		zfcp_erp_adapter_shutdown(adapter, 0, 127, req);
		return -EIO;
	default:
		fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
		dev_err(&adapter->ccw_device->dev,
			"The fibrechannel topology reported by the"
			" adapter is not known by the zfcp driver,"
			" shutting down adapter.\n");
		zfcp_erp_adapter_shutdown(adapter, 0, 128, req);
		return -EIO;
L
Linus Torvalds 已提交
565
	}
S
Swen Schillig 已提交
566

L
Linus Torvalds 已提交
567 568 569
	return 0;
}

S
Swen Schillig 已提交
570
static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
C
Christof Schmitt 已提交
571 572
{
	struct zfcp_adapter *adapter = req->adapter;
S
Swen Schillig 已提交
573 574 575
	struct fsf_qtcb *qtcb = req->qtcb;
	struct fsf_qtcb_bottom_config *bottom = &qtcb->bottom.config;
	struct Scsi_Host *shost = adapter->scsi_host;
C
Christof Schmitt 已提交
576

S
Swen Schillig 已提交
577 578
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
		return;
L
Linus Torvalds 已提交
579

S
Swen Schillig 已提交
580 581 582 583 584 585
	adapter->fsf_lic_version = bottom->lic_version;
	adapter->adapter_features = bottom->adapter_features;
	adapter->connection_features = bottom->connection_features;
	adapter->peer_wwpn = 0;
	adapter->peer_wwnn = 0;
	adapter->peer_d_id = 0;
586

S
Swen Schillig 已提交
587 588 589 590
	switch (qtcb->header.fsf_status) {
	case FSF_GOOD:
		if (zfcp_fsf_exchange_config_evaluate(req))
			return;
L
Linus Torvalds 已提交
591

S
Swen Schillig 已提交
592 593 594 595 596 597 598 599 600 601 602 603
		if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
			dev_err(&adapter->ccw_device->dev,
				"Maximum QTCB size (%d bytes) allowed by "
				"the adapter is lower than the minimum "
				"required by the driver (%ld bytes).\n",
				bottom->max_qtcb_size,
				sizeof(struct fsf_qtcb));
			zfcp_erp_adapter_shutdown(adapter, 0, 129, req);
			return;
		}
		atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
				&adapter->status);
L
Linus Torvalds 已提交
604
		break;
S
Swen Schillig 已提交
605 606 607 608 609 610 611
	case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
		fc_host_node_name(shost) = 0;
		fc_host_port_name(shost) = 0;
		fc_host_port_id(shost) = 0;
		fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
		fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
		adapter->hydra_version = 0;
L
Linus Torvalds 已提交
612

S
Swen Schillig 已提交
613 614
		atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
				&adapter->status);
L
Linus Torvalds 已提交
615

S
Swen Schillig 已提交
616 617
		zfcp_fsf_link_down_info_eval(req, 42,
			&qtcb->header.fsf_status_qual.link_down_info);
L
Linus Torvalds 已提交
618
		break;
S
Swen Schillig 已提交
619 620 621 622
	default:
		zfcp_erp_adapter_shutdown(adapter, 0, 130, req);
		return;
	}
L
Linus Torvalds 已提交
623

S
Swen Schillig 已提交
624 625 626 627 628 629 630
	if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
		adapter->hardware_version = bottom->hardware_version;
		memcpy(fc_host_serial_number(shost), bottom->serial_number,
		       min(FC_SERIAL_NUMBER_SIZE, 17));
		EBCASC(fc_host_serial_number(shost),
		       min(FC_SERIAL_NUMBER_SIZE, 17));
	}
L
Linus Torvalds 已提交
631

S
Swen Schillig 已提交
632 633 634 635 636 637 638 639 640 641 642 643 644 645
	if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) {
		dev_err(&adapter->ccw_device->dev,
			"The adapter only supports newer control block "
			"versions, try updated device driver.\n");
		zfcp_erp_adapter_shutdown(adapter, 0, 125, req);
		return;
	}
	if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
		dev_err(&adapter->ccw_device->dev,
			"The adapter only supports older control block "
			"versions, consider a microcode upgrade.\n");
		zfcp_erp_adapter_shutdown(adapter, 0, 126, req);
	}
}
L
Linus Torvalds 已提交
646

S
Swen Schillig 已提交
647 648 649 650 651
static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req)
{
	struct zfcp_adapter *adapter = req->adapter;
	struct fsf_qtcb_bottom_port *bottom = &req->qtcb->bottom.port;
	struct Scsi_Host *shost = adapter->scsi_host;
L
Linus Torvalds 已提交
652

S
Swen Schillig 已提交
653 654
	if (req->data)
		memcpy(req->data, bottom, sizeof(*bottom));
655

S
Swen Schillig 已提交
656 657 658 659 660 661 662
	if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
		fc_host_permanent_port_name(shost) = bottom->wwpn;
	else
		fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
	fc_host_maxframe_size(shost) = bottom->maximum_frame_size;
	fc_host_supported_speeds(shost) = bottom->supported_speed;
}
L
Linus Torvalds 已提交
663

S
Swen Schillig 已提交
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
{
	struct zfcp_adapter *adapter = req->adapter;
	struct fsf_qtcb *qtcb = req->qtcb;

	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
		return;

	switch (qtcb->header.fsf_status) {
	case FSF_GOOD:
		zfcp_fsf_exchange_port_evaluate(req);
		atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
		break;
	case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
		zfcp_fsf_exchange_port_evaluate(req);
		atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
		zfcp_fsf_link_down_info_eval(req, 43,
			&qtcb->header.fsf_status_qual.link_down_info);
682
		break;
L
Linus Torvalds 已提交
683
	}
S
Swen Schillig 已提交
684
}
685

S
Swen Schillig 已提交
686 687 688 689 690 691 692
static int zfcp_fsf_sbal_check(struct zfcp_qdio_queue *queue)
{
	spin_lock(&queue->lock);
	if (atomic_read(&queue->count))
		return 1;
	spin_unlock(&queue->lock);
	return 0;
L
Linus Torvalds 已提交
693 694
}

S
Swen Schillig 已提交
695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
static int zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter)
{
	long ret;
	struct zfcp_qdio_queue *req_q = &adapter->req_q;

	spin_unlock(&req_q->lock);
	ret = wait_event_interruptible_timeout(adapter->request_wq,
					zfcp_fsf_sbal_check(req_q), 5 * HZ);
	if (ret > 0)
		return 0;

	spin_lock(&req_q->lock);
	return -EIO;
}

static struct zfcp_fsf_req *zfcp_fsf_alloc_noqtcb(mempool_t *pool)
{
	struct zfcp_fsf_req *req;
	req = mempool_alloc(pool, GFP_ATOMIC);
	if (!req)
		return NULL;
	memset(req, 0, sizeof(*req));
	return req;
}

static struct zfcp_fsf_req *zfcp_fsf_alloc_qtcb(mempool_t *pool)
{
	struct zfcp_fsf_req_qtcb *qtcb;

	if (likely(pool))
		qtcb = mempool_alloc(pool, GFP_ATOMIC);
	else
		qtcb = kmem_cache_alloc(zfcp_data.fsf_req_qtcb_cache,
					GFP_ATOMIC);
	if (unlikely(!qtcb))
		return NULL;

	memset(qtcb, 0, sizeof(*qtcb));
	qtcb->fsf_req.qtcb = &qtcb->qtcb;
	qtcb->fsf_req.pool = pool;

	return &qtcb->fsf_req;
}

static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_adapter *adapter,
						u32 fsf_cmd, int req_flags,
						mempool_t *pool)
L
Linus Torvalds 已提交
742 743 744
{
	volatile struct qdio_buffer_element *sbale;

S
Swen Schillig 已提交
745 746
	struct zfcp_fsf_req *req;
	struct zfcp_qdio_queue *req_q = &adapter->req_q;
747

S
Swen Schillig 已提交
748 749 750 751
	if (req_flags & ZFCP_REQ_NO_QTCB)
		req = zfcp_fsf_alloc_noqtcb(pool);
	else
		req = zfcp_fsf_alloc_qtcb(pool);
L
Linus Torvalds 已提交
752

S
Swen Schillig 已提交
753 754
	if (unlikely(!req))
		return ERR_PTR(-EIO);
L
Linus Torvalds 已提交
755

S
Swen Schillig 已提交
756 757
	if (adapter->req_no == 0)
		adapter->req_no++;
L
Linus Torvalds 已提交
758

S
Swen Schillig 已提交
759 760 761
	INIT_LIST_HEAD(&req->list);
	init_timer(&req->timer);
	init_waitqueue_head(&req->completion_wq);
L
Linus Torvalds 已提交
762

S
Swen Schillig 已提交
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
	req->adapter = adapter;
	req->fsf_command = fsf_cmd;
	req->req_id = adapter->req_no++;
	req->sbal_number = 1;
	req->sbal_first = req_q->first;
	req->sbal_last = req_q->first;
	req->sbale_curr = 1;

	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].addr = (void *) req->req_id;
	sbale[0].flags |= SBAL_FLAGS0_COMMAND;

	if (likely(req->qtcb)) {
		req->qtcb->prefix.req_seq_no = req->adapter->fsf_req_seq_no;
		req->qtcb->prefix.req_id = req->req_id;
		req->qtcb->prefix.ulp_info = 26;
		req->qtcb->prefix.qtcb_type = fsf_qtcb_type[req->fsf_command];
		req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION;
		req->qtcb->header.req_handle = req->req_id;
		req->qtcb->header.fsf_command = req->fsf_command;
		req->seq_no = adapter->fsf_req_seq_no;
		req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
		sbale[1].addr = (void *) req->qtcb;
		sbale[1].length = sizeof(struct fsf_qtcb);
	}

	if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)) {
		zfcp_fsf_req_free(req);
		return ERR_PTR(-EIO);
	}
793

S
Swen Schillig 已提交
794 795
	if (likely(req_flags & ZFCP_REQ_AUTO_CLEANUP))
		req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
L
Linus Torvalds 已提交
796

S
Swen Schillig 已提交
797
	return req;
L
Linus Torvalds 已提交
798 799
}

S
Swen Schillig 已提交
800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839
static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
{
	struct zfcp_adapter *adapter = req->adapter;
	struct zfcp_qdio_queue *req_q = &adapter->req_q;
	int idx;

	/* put allocated FSF request into hash table */
	spin_lock(&adapter->req_list_lock);
	idx = zfcp_reqlist_hash(req->req_id);
	list_add_tail(&req->list, &adapter->req_list[idx]);
	spin_unlock(&adapter->req_list_lock);

	req->issued = get_clock();
	if (zfcp_qdio_send(req)) {
		/* Queues are down..... */
		del_timer(&req->timer);
		spin_lock(&adapter->req_list_lock);
		zfcp_reqlist_remove(adapter, req);
		spin_unlock(&adapter->req_list_lock);
		/* undo changes in request queue made for this request */
		atomic_add(req->sbal_number, &req_q->count);
		req_q->first -= req->sbal_number;
		req_q->first += QDIO_MAX_BUFFERS_PER_Q;
		req_q->first %= QDIO_MAX_BUFFERS_PER_Q; /* wrap */
		zfcp_erp_adapter_reopen(adapter, 0, 116, req);
		return -EIO;
	}

	/* Don't increase for unsolicited status */
	if (req->qtcb)
		adapter->fsf_req_seq_no++;

	return 0;
}

/**
 * zfcp_fsf_status_read - send status read request
 * @adapter: pointer to struct zfcp_adapter
 * @req_flags: request flags
 * Returns: 0 on success, ERROR otherwise
L
Linus Torvalds 已提交
840
 */
S
Swen Schillig 已提交
841
int zfcp_fsf_status_read(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
842
{
S
Swen Schillig 已提交
843 844 845 846
	struct zfcp_fsf_req *req;
	struct fsf_status_read_buffer *sr_buf;
	volatile struct qdio_buffer_element *sbale;
	int retval = -EIO;
L
Linus Torvalds 已提交
847

S
Swen Schillig 已提交
848 849 850 851 852 853 854 855 856 857
	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;

	req = zfcp_fsf_req_create(adapter, FSF_QTCB_UNSOLICITED_STATUS,
				  ZFCP_REQ_NO_QTCB,
				  adapter->pool.fsf_req_status_read);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
L
Linus Torvalds 已提交
858 859
	}

S
Swen Schillig 已提交
860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_STATUS;
	sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY;
	req->sbale_curr = 2;

	sr_buf = mempool_alloc(adapter->pool.data_status_read, GFP_ATOMIC);
	if (!sr_buf) {
		retval = -ENOMEM;
		goto failed_buf;
	}
	memset(sr_buf, 0, sizeof(*sr_buf));
	req->data = sr_buf;
	sbale = zfcp_qdio_sbale_curr(req);
	sbale->addr = (void *) sr_buf;
	sbale->length = sizeof(*sr_buf);
875

S
Swen Schillig 已提交
876 877 878
	retval = zfcp_fsf_req_send(req);
	if (retval)
		goto failed_req_send;
L
Linus Torvalds 已提交
879

S
Swen Schillig 已提交
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
	goto out;

failed_req_send:
	mempool_free(sr_buf, adapter->pool.data_status_read);
failed_buf:
	zfcp_fsf_req_free(req);
	zfcp_hba_dbf_event_fsf_unsol("fail", adapter, NULL);
out:
	spin_unlock(&adapter->req_q.lock);
	return retval;
}

static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
{
	struct zfcp_unit *unit = req->data;
	union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual;

	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
		return;

	switch (req->qtcb->header.fsf_status) {
L
Linus Torvalds 已提交
901
	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
902
		if (fsq->word[0] == fsq->word[1]) {
903
			zfcp_erp_adapter_reopen(unit->port->adapter, 0, 104,
S
Swen Schillig 已提交
904 905
						req);
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
906 907 908
		}
		break;
	case FSF_LUN_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
909 910 911
		if (fsq->word[0] == fsq->word[1]) {
			zfcp_erp_port_reopen(unit->port, 0, 105, req);
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
912 913 914
		}
		break;
	case FSF_FCP_COMMAND_DOES_NOT_EXIST:
S
Swen Schillig 已提交
915
		req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
L
Linus Torvalds 已提交
916 917
		break;
	case FSF_PORT_BOXED:
S
Swen Schillig 已提交
918 919 920
		zfcp_erp_port_boxed(unit->port, 47, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
921 922
		break;
	case FSF_LUN_BOXED:
S
Swen Schillig 已提交
923 924 925
		zfcp_erp_unit_boxed(unit, 48, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
926 927
                break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
S
Swen Schillig 已提交
928
		switch (fsq->word[0]) {
L
Linus Torvalds 已提交
929
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
930
			zfcp_test_link(unit->port);
L
Linus Torvalds 已提交
931
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
932
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
933 934 935 936
			break;
		}
		break;
	case FSF_GOOD:
S
Swen Schillig 已提交
937
		req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED;
L
Linus Torvalds 已提交
938 939 940 941 942
		break;
	}
}

/**
S
Swen Schillig 已提交
943 944 945 946 947 948 949 950
 * zfcp_fsf_abort_fcp_command - abort running SCSI command
 * @old_req_id: unsigned long
 * @adapter: pointer to struct zfcp_adapter
 * @unit: pointer to struct zfcp_unit
 * @req_flags: integer specifying the request flags
 * Returns: pointer to struct zfcp_fsf_req
 *
 * FIXME(design): should be watched by a timeout !!!
L
Linus Torvalds 已提交
951 952
 */

S
Swen Schillig 已提交
953 954 955 956
struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
						struct zfcp_adapter *adapter,
						struct zfcp_unit *unit,
						int req_flags)
L
Linus Torvalds 已提交
957 958
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
959
	struct zfcp_fsf_req *req = NULL;
960

S
Swen Schillig 已提交
961 962 963 964 965 966 967
	spin_lock(&adapter->req_q.lock);
	if (!atomic_read(&adapter->req_q.count))
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND,
				  req_flags, adapter->pool.fsf_req_abort);
	if (unlikely(IS_ERR(req)))
		goto out;
968

S
Swen Schillig 已提交
969 970 971
	if (unlikely(!(atomic_read(&unit->status) &
		       ZFCP_STATUS_COMMON_UNBLOCKED)))
		goto out_error_free;
L
Linus Torvalds 已提交
972

S
Swen Schillig 已提交
973 974 975
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
976

S
Swen Schillig 已提交
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992
	req->data = unit;
	req->handler = zfcp_fsf_abort_fcp_command_handler;
	req->qtcb->header.lun_handle = unit->handle;
	req->qtcb->header.port_handle = unit->port->handle;
	req->qtcb->bottom.support.req_handle = (u64) old_req_id;

	zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
	if (!zfcp_fsf_req_send(req))
		goto out;

out_error_free:
	zfcp_fsf_req_free(req);
	req = NULL;
out:
	spin_unlock(&adapter->req_q.lock);
	return req;
L
Linus Torvalds 已提交
993 994
}

S
Swen Schillig 已提交
995
static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
996
{
S
Swen Schillig 已提交
997 998 999 1000
	struct zfcp_adapter *adapter = req->adapter;
	struct zfcp_send_ct *send_ct = req->data;
	struct zfcp_port *port = send_ct->port;
	struct fsf_qtcb_header *header = &req->qtcb->header;
L
Linus Torvalds 已提交
1001

S
Swen Schillig 已提交
1002
	send_ct->status = -EINVAL;
L
Linus Torvalds 已提交
1003

S
Swen Schillig 已提交
1004
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
1005 1006 1007 1008
		goto skip_fsfstatus;

	switch (header->fsf_status) {
        case FSF_GOOD:
S
Swen Schillig 已提交
1009 1010
		zfcp_san_dbf_event_ct_response(req);
		send_ct->status = 0;
L
Linus Torvalds 已提交
1011 1012
		break;
        case FSF_SERVICE_CLASS_NOT_SUPPORTED:
S
Swen Schillig 已提交
1013
		zfcp_fsf_class_not_supp(req);
L
Linus Torvalds 已提交
1014 1015 1016 1017 1018 1019
		break;
        case FSF_ADAPTER_STATUS_AVAILABLE:
                switch (header->fsf_status_qual.word[0]){
                case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
			zfcp_test_link(port);
                case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
1020
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1021 1022 1023 1024
			break;
                }
                break;
	case FSF_ACCESS_DENIED:
S
Swen Schillig 已提交
1025
		zfcp_fsf_access_denied_port(req, port);
L
Linus Torvalds 已提交
1026 1027
		break;
        case FSF_PORT_BOXED:
S
Swen Schillig 已提交
1028 1029 1030
		zfcp_erp_port_boxed(port, 49, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
1031
		break;
S
Swen Schillig 已提交
1032 1033 1034
	case FSF_PORT_HANDLE_NOT_VALID:
		zfcp_erp_adapter_reopen(adapter, 0, 106, req);
	case FSF_GENERIC_COMMAND_REJECTED:
L
Linus Torvalds 已提交
1035 1036 1037 1038
	case FSF_PAYLOAD_SIZE_MISMATCH:
	case FSF_REQUEST_SIZE_TOO_LARGE:
	case FSF_RESPONSE_SIZE_TOO_LARGE:
	case FSF_SBAL_MISMATCH:
S
Swen Schillig 已提交
1039
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1040 1041 1042 1043
		break;
	}

skip_fsfstatus:
S
Swen Schillig 已提交
1044
	if (send_ct->handler)
L
Linus Torvalds 已提交
1045
		send_ct->handler(send_ct->handler_data);
S
Swen Schillig 已提交
1046
}
L
Linus Torvalds 已提交
1047

S
Swen Schillig 已提交
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
static int zfcp_fsf_setup_sbals(struct zfcp_fsf_req *req,
				struct scatterlist *sg_req,
				struct scatterlist *sg_resp, int max_sbals)
{
	int bytes;

	bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ,
					sg_req, max_sbals);
	if (bytes <= 0)
		return -ENOMEM;
	req->qtcb->bottom.support.req_buf_length = bytes;
	req->sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;

	bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ,
					sg_resp, max_sbals);
	if (bytes <= 0)
		return -ENOMEM;
	req->qtcb->bottom.support.resp_buf_length = bytes;

	return 0;
L
Linus Torvalds 已提交
1068 1069 1070
}

/**
S
Swen Schillig 已提交
1071 1072 1073 1074
 * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
 * @ct: pointer to struct zfcp_send_ct with data for request
 * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
 * @erp_action: if non-null the Generic Service request sent within ERP
L
Linus Torvalds 已提交
1075
 */
S
Swen Schillig 已提交
1076 1077
int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool,
		     struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1078
{
S
Swen Schillig 已提交
1079 1080 1081 1082
	struct zfcp_port *port = ct->port;
	struct zfcp_adapter *adapter = port->adapter;
	struct zfcp_fsf_req *req;
	int ret = -EIO;
L
Linus Torvalds 已提交
1083

S
Swen Schillig 已提交
1084 1085 1086
	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;
L
Linus Torvalds 已提交
1087

S
Swen Schillig 已提交
1088 1089 1090 1091 1092
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_GENERIC,
				  ZFCP_REQ_AUTO_CLEANUP, pool);
	if (unlikely(IS_ERR(req))) {
		ret = PTR_ERR(req);
		goto out;
1093 1094
	}

S
Swen Schillig 已提交
1095 1096
	ret = zfcp_fsf_setup_sbals(req, ct->req, ct->resp,
				   FSF_MAX_SBALS_PER_REQ);
C
Christof Schmitt 已提交
1097
	if (ret)
L
Linus Torvalds 已提交
1098 1099
		goto failed_send;

S
Swen Schillig 已提交
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
	req->handler = zfcp_fsf_send_ct_handler;
	req->qtcb->header.port_handle = port->handle;
	req->qtcb->bottom.support.service_class = FSF_CLASS_3;
	req->qtcb->bottom.support.timeout = ct->timeout;
	req->data = ct;

	zfcp_san_dbf_event_ct_request(req);

	if (erp_action) {
		erp_action->fsf_req = req;
		req->erp_action = erp_action;
		zfcp_erp_start_timer(req);
	} else
		zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
L
Linus Torvalds 已提交
1114

S
Swen Schillig 已提交
1115 1116 1117
	ret = zfcp_fsf_req_send(req);
	if (ret)
		goto failed_send;
L
Linus Torvalds 已提交
1118

S
Swen Schillig 已提交
1119
	goto out;
L
Linus Torvalds 已提交
1120

S
Swen Schillig 已提交
1121 1122 1123 1124 1125 1126 1127
failed_send:
	zfcp_fsf_req_free(req);
	if (erp_action)
		erp_action->fsf_req = NULL;
out:
	spin_unlock(&adapter->req_q.lock);
	return ret;
L
Linus Torvalds 已提交
1128 1129
}

S
Swen Schillig 已提交
1130
static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1131
{
S
Swen Schillig 已提交
1132 1133 1134
	struct zfcp_send_els *send_els = req->data;
	struct zfcp_port *port = send_els->port;
	struct fsf_qtcb_header *header = &req->qtcb->header;
L
Linus Torvalds 已提交
1135

S
Swen Schillig 已提交
1136
	send_els->status = -EINVAL;
L
Linus Torvalds 已提交
1137

S
Swen Schillig 已提交
1138
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
1139 1140 1141 1142
		goto skip_fsfstatus;

	switch (header->fsf_status) {
	case FSF_GOOD:
S
Swen Schillig 已提交
1143 1144
		zfcp_san_dbf_event_els_response(req);
		send_els->status = 0;
L
Linus Torvalds 已提交
1145 1146
		break;
	case FSF_SERVICE_CLASS_NOT_SUPPORTED:
S
Swen Schillig 已提交
1147
		zfcp_fsf_class_not_supp(req);
L
Linus Torvalds 已提交
1148 1149 1150 1151
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		switch (header->fsf_status_qual.word[0]){
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1152 1153
			if (port && (send_els->ls_code != ZFCP_LS_ADISC))
				zfcp_test_link(port);
S
Swen Schillig 已提交
1154
			/*fall through */
L
Linus Torvalds 已提交
1155 1156
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
		case FSF_SQ_RETRY_IF_POSSIBLE:
S
Swen Schillig 已提交
1157
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1158 1159 1160 1161 1162 1163 1164 1165 1166
			break;
		}
		break;
	case FSF_ELS_COMMAND_REJECTED:
	case FSF_PAYLOAD_SIZE_MISMATCH:
	case FSF_REQUEST_SIZE_TOO_LARGE:
	case FSF_RESPONSE_SIZE_TOO_LARGE:
		break;
	case FSF_ACCESS_DENIED:
S
Swen Schillig 已提交
1167
		zfcp_fsf_access_denied_port(req, port);
L
Linus Torvalds 已提交
1168
		break;
S
Swen Schillig 已提交
1169 1170 1171
	case FSF_SBAL_MISMATCH:
		/* should never occure, avoided in zfcp_fsf_send_els */
		/* fall through */
L
Linus Torvalds 已提交
1172
	default:
S
Swen Schillig 已提交
1173
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1174 1175 1176
		break;
	}
skip_fsfstatus:
H
Heiko Carstens 已提交
1177
	if (send_els->handler)
L
Linus Torvalds 已提交
1178
		send_els->handler(send_els->handler_data);
S
Swen Schillig 已提交
1179
}
L
Linus Torvalds 已提交
1180

S
Swen Schillig 已提交
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
/**
 * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
 * @els: pointer to struct zfcp_send_els with data for the command
 */
int zfcp_fsf_send_els(struct zfcp_send_els *els)
{
	struct zfcp_fsf_req *req;
	struct zfcp_adapter *adapter = els->adapter;
	struct fsf_qtcb_bottom_support *bottom;
	int ret = -EIO;

	if (unlikely(!(atomic_read(&els->port->status) &
		       ZFCP_STATUS_COMMON_UNBLOCKED)))
		return -EBUSY;

	spin_lock(&adapter->req_q.lock);
	if (!atomic_read(&adapter->req_q.count))
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS,
				  ZFCP_REQ_AUTO_CLEANUP, NULL);
	if (unlikely(IS_ERR(req))) {
		ret = PTR_ERR(req);
		goto out;
	}

	ret = zfcp_fsf_setup_sbals(req, els->req, els->resp,
				   FSF_MAX_SBALS_PER_ELS_REQ);
	if (ret)
		goto failed_send;

	bottom = &req->qtcb->bottom.support;
	req->handler = zfcp_fsf_send_els_handler;
	bottom->d_id = els->d_id;
	bottom->service_class = FSF_CLASS_3;
	bottom->timeout = 2 * R_A_TOV;
	req->data = els;

	zfcp_san_dbf_event_els_request(req);

	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	ret = zfcp_fsf_req_send(req);
	if (ret)
		goto failed_send;

	goto out;

failed_send:
	zfcp_fsf_req_free(req);
out:
	spin_unlock(&adapter->req_q.lock);
	return ret;
L
Linus Torvalds 已提交
1232 1233
}

S
Swen Schillig 已提交
1234
int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1235 1236
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1237
	struct zfcp_fsf_req *req;
1238
	struct zfcp_adapter *adapter = erp_action->adapter;
S
Swen Schillig 已提交
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
	int retval = -EIO;

	spin_lock(&adapter->req_q.lock);
	if (!atomic_read(&adapter->req_q.count))
		goto out;
	req = zfcp_fsf_req_create(adapter,
				  FSF_QTCB_EXCHANGE_CONFIG_DATA,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
L
Linus Torvalds 已提交
1251 1252
	}

S
Swen Schillig 已提交
1253
	sbale = zfcp_qdio_sbale_req(req);
1254 1255
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
1256

S
Swen Schillig 已提交
1257
	req->qtcb->bottom.config.feature_selection =
1258 1259
			FSF_FEATURE_CFDC |
			FSF_FEATURE_LUN_SHARING |
1260
			FSF_FEATURE_NOTIFICATION_LOST |
1261
			FSF_FEATURE_UPDATE_ALERT;
S
Swen Schillig 已提交
1262 1263 1264
	req->erp_action = erp_action;
	req->handler = zfcp_fsf_exchange_config_data_handler;
	erp_action->fsf_req = req;
L
Linus Torvalds 已提交
1265

S
Swen Schillig 已提交
1266 1267
	zfcp_erp_start_timer(req);
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1268
	if (retval) {
S
Swen Schillig 已提交
1269
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1270 1271
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1272 1273
out:
	spin_unlock(&adapter->req_q.lock);
1274 1275
	return retval;
}
L
Linus Torvalds 已提交
1276

S
Swen Schillig 已提交
1277 1278
int zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter,
				       struct fsf_qtcb_bottom_config *data)
1279 1280
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
	struct zfcp_fsf_req *req = NULL;
	int retval = -EIO;

	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;

	req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_CONFIG_DATA,
				  0, NULL);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
1293 1294
	}

S
Swen Schillig 已提交
1295
	sbale = zfcp_qdio_sbale_req(req);
1296 1297
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
S
Swen Schillig 已提交
1298
	req->handler = zfcp_fsf_exchange_config_data_handler;
1299

S
Swen Schillig 已提交
1300
	req->qtcb->bottom.config.feature_selection =
1301 1302 1303 1304 1305 1306
			FSF_FEATURE_CFDC |
			FSF_FEATURE_LUN_SHARING |
			FSF_FEATURE_NOTIFICATION_LOST |
			FSF_FEATURE_UPDATE_ALERT;

	if (data)
S
Swen Schillig 已提交
1307
		req->data = data;
1308

S
Swen Schillig 已提交
1309 1310 1311 1312
	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	retval = zfcp_fsf_req_send(req);
out:
	spin_unlock(&adapter->req_q.lock);
C
Christof Schmitt 已提交
1313
	if (!retval)
S
Swen Schillig 已提交
1314 1315
		wait_event(req->completion_wq,
			   req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
1316

S
Swen Schillig 已提交
1317
	zfcp_fsf_req_free(req);
1318

L
Linus Torvalds 已提交
1319 1320 1321 1322 1323
	return retval;
}

/**
 * zfcp_fsf_exchange_port_data - request information about local port
1324
 * @erp_action: ERP action for the adapter for which port data is requested
S
Swen Schillig 已提交
1325
 * Returns: 0 on success, error otherwise
L
Linus Torvalds 已提交
1326
 */
S
Swen Schillig 已提交
1327
int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1328 1329
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1330
	struct zfcp_fsf_req *req;
1331
	struct zfcp_adapter *adapter = erp_action->adapter;
S
Swen Schillig 已提交
1332
	int retval = -EIO;
L
Linus Torvalds 已提交
1333

C
Christof Schmitt 已提交
1334
	if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1335
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
1336

S
Swen Schillig 已提交
1337 1338 1339 1340 1341 1342 1343 1344 1345
	spin_lock(&adapter->req_q.lock);
	if (!atomic_read(&adapter->req_q.count))
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
1346 1347
	}

S
Swen Schillig 已提交
1348
	sbale = zfcp_qdio_sbale_req(req);
1349 1350
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
1351

S
Swen Schillig 已提交
1352 1353 1354
	req->handler = zfcp_fsf_exchange_port_data_handler;
	req->erp_action = erp_action;
	erp_action->fsf_req = req;
1355

S
Swen Schillig 已提交
1356 1357
	zfcp_erp_start_timer(req);
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1358
	if (retval) {
S
Swen Schillig 已提交
1359
		zfcp_fsf_req_free(req);
1360 1361
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1362 1363
out:
	spin_unlock(&adapter->req_q.lock);
1364 1365 1366 1367 1368
	return retval;
}

/**
 * zfcp_fsf_exchange_port_data_sync - request information about local port
S
Swen Schillig 已提交
1369 1370 1371
 * @adapter: pointer to struct zfcp_adapter
 * @data: pointer to struct fsf_qtcb_bottom_port
 * Returns: 0 on success, error otherwise
1372
 */
S
Swen Schillig 已提交
1373 1374
int zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter *adapter,
				     struct fsf_qtcb_bottom_port *data)
1375 1376
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1377 1378
	struct zfcp_fsf_req *req = NULL;
	int retval = -EIO;
1379

C
Christof Schmitt 已提交
1380
	if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1381 1382
		return -EOPNOTSUPP;

S
Swen Schillig 已提交
1383 1384 1385 1386 1387 1388 1389 1390 1391
	spin_lock(&adapter->req_q.lock);
	if (!atomic_read(&adapter->req_q.count))
		goto out;

	req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA, 0,
				  NULL);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
L
Linus Torvalds 已提交
1392 1393
	}

1394
	if (data)
S
Swen Schillig 已提交
1395
		req->data = data;
1396

S
Swen Schillig 已提交
1397
	sbale = zfcp_qdio_sbale_req(req);
1398 1399 1400
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
1401 1402 1403 1404 1405
	req->handler = zfcp_fsf_exchange_port_data_handler;
	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	retval = zfcp_fsf_req_send(req);
out:
	spin_unlock(&adapter->req_q.lock);
C
Christof Schmitt 已提交
1406
	if (!retval)
S
Swen Schillig 已提交
1407 1408 1409
		wait_event(req->completion_wq,
			   req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
	zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1410 1411 1412 1413

	return retval;
}

S
Swen Schillig 已提交
1414
static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1415
{
S
Swen Schillig 已提交
1416 1417
	struct zfcp_port *port = req->data;
	struct fsf_qtcb_header *header = &req->qtcb->header;
L
Linus Torvalds 已提交
1418 1419
	struct fsf_plogi *plogi;

S
Swen Schillig 已提交
1420
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
1421 1422 1423 1424 1425 1426
		goto skip_fsfstatus;

	switch (header->fsf_status) {
	case FSF_PORT_ALREADY_OPEN:
		break;
	case FSF_ACCESS_DENIED:
S
Swen Schillig 已提交
1427
		zfcp_fsf_access_denied_port(req, port);
L
Linus Torvalds 已提交
1428 1429
		break;
	case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
S
Swen Schillig 已提交
1430
		dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
1431 1432 1433
			 "The adapter is out of resources. The remote port "
			 "0x%016Lx could not be opened, disabling it.\n",
			 port->wwpn);
S
Swen Schillig 已提交
1434 1435
		zfcp_erp_port_failed(port, 31, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1436 1437 1438 1439 1440
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		switch (header->fsf_status_qual.word[0]) {
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
1441
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1442 1443
			break;
		case FSF_SQ_NO_RETRY_POSSIBLE:
S
Swen Schillig 已提交
1444
			dev_warn(&req->adapter->ccw_device->dev,
C
Christof Schmitt 已提交
1445 1446
				 "The remote port 0x%016Lx could not be "
				 "opened. Disabling it.\n", port->wwpn);
S
Swen Schillig 已提交
1447 1448
			zfcp_erp_port_failed(port, 32, req);
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1449 1450 1451 1452 1453 1454 1455
			break;
		}
		break;
	case FSF_GOOD:
		port->handle = header->port_handle;
		atomic_set_mask(ZFCP_STATUS_COMMON_OPEN |
				ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1456 1457 1458
		atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
		                  ZFCP_STATUS_COMMON_ACCESS_BOXED,
		                  &port->status);
L
Linus Torvalds 已提交
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
		/* check whether D_ID has changed during open */
		/*
		 * FIXME: This check is not airtight, as the FCP channel does
		 * not monitor closures of target port connections caused on
		 * the remote side. Thus, they might miss out on invalidating
		 * locally cached WWPNs (and other N_Port parameters) of gone
		 * target ports. So, our heroic attempt to make things safe
		 * could be undermined by 'open port' response data tagged with
		 * obsolete WWPNs. Another reason to monitor potential
		 * connection closures ourself at least (by interpreting
		 * incoming ELS' and unsolicited status). It just crosses my
		 * mind that one should be able to cross-check by means of
		 * another GID_PN straight after a port has been opened.
		 * Alternately, an ADISC/PDISC ELS should suffice, as well.
		 */
S
Swen Schillig 已提交
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
		if (atomic_read(&port->status) & ZFCP_STATUS_PORT_NO_WWPN)
			break;

		plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els;
		if (req->qtcb->bottom.support.els1_length >= sizeof(*plogi)) {
			if (plogi->serv_param.wwpn != port->wwpn)
				atomic_clear_mask(ZFCP_STATUS_PORT_DID_DID,
						  &port->status);
			else {
				port->wwnn = plogi->serv_param.wwnn;
				zfcp_fc_plogi_evaluate(port, plogi);
L
Linus Torvalds 已提交
1485 1486 1487 1488
			}
		}
		break;
	case FSF_UNKNOWN_OP_SUBTYPE:
S
Swen Schillig 已提交
1489
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1490 1491 1492
		break;
	}

S
Swen Schillig 已提交
1493
skip_fsfstatus:
L
Linus Torvalds 已提交
1494 1495 1496
	atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &port->status);
}

S
Swen Schillig 已提交
1497 1498 1499 1500
/**
 * zfcp_fsf_open_port - create and send open port request
 * @erp_action: pointer to struct zfcp_erp_action
 * Returns: 0 on success, error otherwise
L
Linus Torvalds 已提交
1501
 */
S
Swen Schillig 已提交
1502
int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1503 1504
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;

	req = zfcp_fsf_req_create(adapter,
				  FSF_QTCB_OPEN_PORT_WITH_DID,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
L
Linus Torvalds 已提交
1519
		goto out;
S
Swen Schillig 已提交
1520
	}
L
Linus Torvalds 已提交
1521

S
Swen Schillig 已提交
1522
	sbale = zfcp_qdio_sbale_req(req);
L
Linus Torvalds 已提交
1523 1524 1525
        sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
        sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
1526 1527 1528 1529 1530 1531 1532 1533 1534
	req->handler = zfcp_fsf_open_port_handler;
	req->qtcb->bottom.support.d_id = erp_action->port->d_id;
	req->data = erp_action->port;
	req->erp_action = erp_action;
	erp_action->fsf_req = req;
	atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->port->status);

	zfcp_erp_start_timer(req);
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1535
	if (retval) {
S
Swen Schillig 已提交
1536
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1537 1538
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1539 1540
out:
	spin_unlock(&adapter->req_q.lock);
L
Linus Torvalds 已提交
1541 1542 1543
	return retval;
}

S
Swen Schillig 已提交
1544
static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1545
{
S
Swen Schillig 已提交
1546
	struct zfcp_port *port = req->data;
L
Linus Torvalds 已提交
1547

S
Swen Schillig 已提交
1548
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
1549 1550
		goto skip_fsfstatus;

S
Swen Schillig 已提交
1551
	switch (req->qtcb->header.fsf_status) {
L
Linus Torvalds 已提交
1552
	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1553 1554
		zfcp_erp_adapter_reopen(port->adapter, 0, 107, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1555 1556 1557 1558
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		break;
	case FSF_GOOD:
S
Swen Schillig 已提交
1559
		zfcp_erp_modify_port_status(port, 33, req,
L
Linus Torvalds 已提交
1560 1561 1562 1563 1564
					    ZFCP_STATUS_COMMON_OPEN,
					    ZFCP_CLEAR);
		break;
	}

S
Swen Schillig 已提交
1565
skip_fsfstatus:
L
Linus Torvalds 已提交
1566 1567 1568
	atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &port->status);
}

S
Swen Schillig 已提交
1569 1570 1571 1572
/**
 * zfcp_fsf_close_port - create and send close port request
 * @erp_action: pointer to struct zfcp_erp_action
 * Returns: 0 on success, error otherwise
L
Linus Torvalds 已提交
1573
 */
S
Swen Schillig 已提交
1574
int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1575 1576
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;

	req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
L
Linus Torvalds 已提交
1590
		goto out;
S
Swen Schillig 已提交
1591
	}
L
Linus Torvalds 已提交
1592

S
Swen Schillig 已提交
1593
	sbale = zfcp_qdio_sbale_req(req);
L
Linus Torvalds 已提交
1594 1595 1596
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
1597 1598 1599 1600 1601 1602 1603 1604 1605
	req->handler = zfcp_fsf_close_port_handler;
	req->data = erp_action->port;
	req->erp_action = erp_action;
	req->qtcb->header.port_handle = erp_action->port->handle;
	erp_action->fsf_req = req;
	atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->port->status);

	zfcp_erp_start_timer(req);
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1606
	if (retval) {
S
Swen Schillig 已提交
1607
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1608 1609
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1610 1611
out:
	spin_unlock(&adapter->req_q.lock);
L
Linus Torvalds 已提交
1612 1613 1614
	return retval;
}

S
Swen Schillig 已提交
1615
static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1616
{
S
Swen Schillig 已提交
1617 1618
	struct zfcp_port *port = req->data;
	struct fsf_qtcb_header *header = &req->qtcb->header;
L
Linus Torvalds 已提交
1619 1620
	struct zfcp_unit *unit;

S
Swen Schillig 已提交
1621
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
1622 1623 1624 1625
		goto skip_fsfstatus;

	switch (header->fsf_status) {
	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1626 1627
		zfcp_erp_adapter_reopen(port->adapter, 0, 108, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1628 1629
		break;
	case FSF_ACCESS_DENIED:
S
Swen Schillig 已提交
1630
		zfcp_fsf_access_denied_port(req, port);
L
Linus Torvalds 已提交
1631 1632
		break;
	case FSF_PORT_BOXED:
S
Swen Schillig 已提交
1633 1634 1635
		zfcp_erp_port_boxed(port, 50, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
1636 1637 1638 1639 1640 1641
		/* can't use generic zfcp_erp_modify_port_status because
		 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
		atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
		list_for_each_entry(unit, &port->unit_list_head, list)
			atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
					  &unit->status);
L
Linus Torvalds 已提交
1642 1643 1644 1645
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		switch (header->fsf_status_qual.word[0]) {
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
S
Swen Schillig 已提交
1646
			/* fall through */
L
Linus Torvalds 已提交
1647
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
1648
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1649 1650 1651 1652 1653 1654 1655 1656 1657
			break;
		}
		break;
	case FSF_GOOD:
		/* can't use generic zfcp_erp_modify_port_status because
		 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
		 */
		atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
		list_for_each_entry(unit, &port->unit_list_head, list)
S
Swen Schillig 已提交
1658 1659
			atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
					  &unit->status);
L
Linus Torvalds 已提交
1660 1661
		break;
	}
S
Swen Schillig 已提交
1662
skip_fsfstatus:
L
Linus Torvalds 已提交
1663 1664 1665
	atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_CLOSING, &port->status);
}

S
Swen Schillig 已提交
1666 1667 1668 1669
/**
 * zfcp_fsf_close_physical_port - close physical port
 * @erp_action: pointer to struct zfcp_erp_action
 * Returns: 0 on success
L
Linus Torvalds 已提交
1670
 */
S
Swen Schillig 已提交
1671
int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1672 1673
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1674 1675 1676 1677 1678 1679
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
L
Linus Torvalds 已提交
1680 1681
		goto out;

S
Swen Schillig 已提交
1682 1683 1684 1685 1686 1687 1688
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PHYSICAL_PORT,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
	}
L
Linus Torvalds 已提交
1689

S
Swen Schillig 已提交
1690 1691 1692
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
1693

S
Swen Schillig 已提交
1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
	req->data = erp_action->port;
	req->qtcb->header.port_handle = erp_action->port->handle;
	req->erp_action = erp_action;
	req->handler = zfcp_fsf_close_physical_port_handler;
	erp_action->fsf_req = req;
	atomic_set_mask(ZFCP_STATUS_PORT_PHYS_CLOSING,
			&erp_action->port->status);

	zfcp_erp_start_timer(req);
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1704
	if (retval) {
S
Swen Schillig 已提交
1705
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1706 1707
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1708 1709
out:
	spin_unlock(&adapter->req_q.lock);
L
Linus Torvalds 已提交
1710 1711 1712
	return retval;
}

S
Swen Schillig 已提交
1713
static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1714
{
S
Swen Schillig 已提交
1715 1716 1717 1718 1719 1720
	struct zfcp_adapter *adapter = req->adapter;
	struct zfcp_unit *unit = req->data;
	struct fsf_qtcb_header *header = &req->qtcb->header;
	struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
	struct fsf_queue_designator *queue_designator =
				&header->fsf_status_qual.fsf_queue_designator;
1721
	int exclusive, readwrite;
L
Linus Torvalds 已提交
1722

S
Swen Schillig 已提交
1723
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
1724 1725 1726
		goto skip_fsfstatus;

	atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1727
			  ZFCP_STATUS_COMMON_ACCESS_BOXED |
L
Linus Torvalds 已提交
1728 1729 1730 1731 1732 1733 1734
			  ZFCP_STATUS_UNIT_SHARED |
			  ZFCP_STATUS_UNIT_READONLY,
			  &unit->status);

	switch (header->fsf_status) {

	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1735 1736
		zfcp_erp_adapter_reopen(unit->port->adapter, 0, 109, req);
		/* fall through */
L
Linus Torvalds 已提交
1737 1738 1739
	case FSF_LUN_ALREADY_OPEN:
		break;
	case FSF_ACCESS_DENIED:
S
Swen Schillig 已提交
1740
		zfcp_fsf_access_denied_unit(req, unit);
L
Linus Torvalds 已提交
1741
		atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
C
Christof Schmitt 已提交
1742
		atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
L
Linus Torvalds 已提交
1743 1744
		break;
	case FSF_PORT_BOXED:
S
Swen Schillig 已提交
1745 1746 1747
		zfcp_erp_port_boxed(unit->port, 51, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
1748 1749
		break;
	case FSF_LUN_SHARING_VIOLATION:
S
Swen Schillig 已提交
1750
		if (header->fsf_status_qual.word[0])
C
Christof Schmitt 已提交
1751 1752 1753 1754 1755 1756 1757 1758 1759
			dev_warn(&adapter->ccw_device->dev,
				 "FCP-LUN 0x%Lx at the remote port "
				 "with WWPN 0x%Lx "
				 "connected to the adapter "
				 "is already in use in LPAR%d, CSS%d.\n",
				 unit->fcp_lun,
				 unit->port->wwpn,
				 queue_designator->hla,
				 queue_designator->cssid);
S
Swen Schillig 已提交
1760
		else
C
Christof Schmitt 已提交
1761 1762
			zfcp_act_eval_err(adapter,
					  header->fsf_status_qual.word[2]);
S
Swen Schillig 已提交
1763
		zfcp_erp_unit_access_denied(unit, 60, req);
L
Linus Torvalds 已提交
1764 1765
		atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
		atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
S
Swen Schillig 已提交
1766
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1767 1768
		break;
	case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
S
Swen Schillig 已提交
1769
		dev_warn(&adapter->ccw_device->dev,
C
Christof Schmitt 已提交
1770 1771 1772
			 "The adapter ran out of resources. There is no "
			 "handle available for unit 0x%016Lx on port 0x%016Lx.",
			 unit->fcp_lun, unit->port->wwpn);
S
Swen Schillig 已提交
1773 1774 1775 1776
		zfcp_erp_unit_failed(unit, 34, req);
		/* fall through */
	case FSF_INVALID_COMMAND_OPTION:
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1777 1778 1779 1780
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		switch (header->fsf_status_qual.word[0]) {
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1781
			zfcp_test_link(unit->port);
S
Swen Schillig 已提交
1782
			/* fall through */
L
Linus Torvalds 已提交
1783
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
1784
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1785 1786 1787 1788 1789 1790 1791
			break;
		}
		break;

	case FSF_GOOD:
		unit->handle = header->lun_handle;
		atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
1792 1793 1794 1795 1796 1797 1798 1799 1800

		if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE) &&
		    (adapter->adapter_features & FSF_FEATURE_LUN_SHARING) &&
		    (adapter->ccw_device->id.dev_model != ZFCP_DEVICE_MODEL_PRIV)) {
			exclusive = (bottom->lun_access_info &
					FSF_UNIT_ACCESS_EXCLUSIVE);
			readwrite = (bottom->lun_access_info &
					FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);

L
Linus Torvalds 已提交
1801 1802 1803 1804 1805 1806 1807
			if (!exclusive)
		                atomic_set_mask(ZFCP_STATUS_UNIT_SHARED,
						&unit->status);

			if (!readwrite) {
                		atomic_set_mask(ZFCP_STATUS_UNIT_READONLY,
						&unit->status);
S
Swen Schillig 已提交
1808
				dev_info(&adapter->ccw_device->dev,
C
Christof Schmitt 已提交
1809 1810 1811
					 "Read-only access for unit 0x%016Lx "
					 "on port 0x%016Lx.\n",
					 unit->fcp_lun, unit->port->wwpn);
L
Linus Torvalds 已提交
1812 1813 1814
        		}

        		if (exclusive && !readwrite) {
S
Swen Schillig 已提交
1815
				dev_err(&adapter->ccw_device->dev,
C
Christof Schmitt 已提交
1816 1817 1818 1819
					"Exclusive access of read-only unit "
					"0x%016Lx on port 0x%016Lx not "
					"supported, disabling unit.\n",
					unit->fcp_lun, unit->port->wwpn);
S
Swen Schillig 已提交
1820 1821 1822
				zfcp_erp_unit_failed(unit, 35, req);
				req->status |= ZFCP_STATUS_FSFREQ_ERROR;
				zfcp_erp_unit_shutdown(unit, 0, 80, req);
L
Linus Torvalds 已提交
1823
        		} else if (!exclusive && readwrite) {
S
Swen Schillig 已提交
1824
				dev_err(&adapter->ccw_device->dev,
C
Christof Schmitt 已提交
1825 1826 1827 1828
					"Shared access of read-write unit "
					"0x%016Lx on port 0x%016Lx not "
					"supported, disabling unit.\n",
					unit->fcp_lun, unit->port->wwpn);
S
Swen Schillig 已提交
1829 1830 1831
				zfcp_erp_unit_failed(unit, 36, req);
				req->status |= ZFCP_STATUS_FSFREQ_ERROR;
				zfcp_erp_unit_shutdown(unit, 0, 81, req);
L
Linus Torvalds 已提交
1832 1833 1834 1835 1836
        		}
		}
		break;
	}

S
Swen Schillig 已提交
1837
skip_fsfstatus:
L
Linus Torvalds 已提交
1838 1839 1840
	atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &unit->status);
}

S
Swen Schillig 已提交
1841 1842 1843 1844
/**
 * zfcp_fsf_open_unit - open unit
 * @erp_action: pointer to struct zfcp_erp_action
 * Returns: 0 on success, error otherwise
L
Linus Torvalds 已提交
1845
 */
S
Swen Schillig 已提交
1846
int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1847 1848
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1849 1850 1851 1852 1853 1854
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
L
Linus Torvalds 已提交
1855 1856
		goto out;

S
Swen Schillig 已提交
1857 1858 1859 1860 1861 1862 1863 1864 1865
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_OPEN_LUN,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
	}

	sbale = zfcp_qdio_sbale_req(req);
L
Linus Torvalds 已提交
1866 1867 1868
        sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
        sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
	req->qtcb->header.port_handle = erp_action->port->handle;
	req->qtcb->bottom.support.fcp_lun = erp_action->unit->fcp_lun;
	req->handler = zfcp_fsf_open_unit_handler;
	req->data = erp_action->unit;
	req->erp_action = erp_action;
	erp_action->fsf_req = req;

	if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
		req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;

	atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->unit->status);
L
Linus Torvalds 已提交
1880

S
Swen Schillig 已提交
1881 1882
	zfcp_erp_start_timer(req);
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1883
	if (retval) {
S
Swen Schillig 已提交
1884
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1885 1886
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1887 1888
out:
	spin_unlock(&adapter->req_q.lock);
L
Linus Torvalds 已提交
1889 1890 1891
	return retval;
}

S
Swen Schillig 已提交
1892
static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1893
{
S
Swen Schillig 已提交
1894
	struct zfcp_unit *unit = req->data;
L
Linus Torvalds 已提交
1895

S
Swen Schillig 已提交
1896
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
1897 1898
		goto skip_fsfstatus;

S
Swen Schillig 已提交
1899
	switch (req->qtcb->header.fsf_status) {
L
Linus Torvalds 已提交
1900
	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1901 1902
		zfcp_erp_adapter_reopen(unit->port->adapter, 0, 110, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1903 1904
		break;
	case FSF_LUN_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1905 1906
		zfcp_erp_port_reopen(unit->port, 0, 111, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1907 1908
		break;
	case FSF_PORT_BOXED:
S
Swen Schillig 已提交
1909 1910 1911
		zfcp_erp_port_boxed(unit->port, 52, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
1912 1913
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
S
Swen Schillig 已提交
1914
		switch (req->qtcb->header.fsf_status_qual.word[0]) {
L
Linus Torvalds 已提交
1915
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1916
			zfcp_test_link(unit->port);
S
Swen Schillig 已提交
1917
			/* fall through */
L
Linus Torvalds 已提交
1918
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
1919
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1920 1921 1922 1923 1924 1925 1926
			break;
		}
		break;
	case FSF_GOOD:
		atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
		break;
	}
S
Swen Schillig 已提交
1927
skip_fsfstatus:
L
Linus Torvalds 已提交
1928 1929 1930 1931
	atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &unit->status);
}

/**
S
Swen Schillig 已提交
1932 1933 1934
 * zfcp_fsf_close_unit - close zfcp unit
 * @erp_action: pointer to struct zfcp_unit
 * Returns: 0 on success, error otherwise
L
Linus Torvalds 已提交
1935
 */
S
Swen Schillig 已提交
1936
int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1937 1938
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1939 1940 1941
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;
L
Linus Torvalds 已提交
1942

S
Swen Schillig 已提交
1943 1944
	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
L
Linus Torvalds 已提交
1945
		goto out;
S
Swen Schillig 已提交
1946 1947 1948 1949 1950 1951 1952
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_LUN,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
	}
L
Linus Torvalds 已提交
1953

S
Swen Schillig 已提交
1954 1955
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
L
Linus Torvalds 已提交
1956 1957
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
1958 1959 1960 1961 1962 1963 1964
	req->qtcb->header.port_handle = erp_action->port->handle;
	req->qtcb->header.lun_handle = erp_action->unit->handle;
	req->handler = zfcp_fsf_close_unit_handler;
	req->data = erp_action->unit;
	req->erp_action = erp_action;
	erp_action->fsf_req = req;
	atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->unit->status);
1965

S
Swen Schillig 已提交
1966 1967 1968 1969 1970 1971 1972 1973 1974
	zfcp_erp_start_timer(req);
	retval = zfcp_fsf_req_send(req);
	if (retval) {
		zfcp_fsf_req_free(req);
		erp_action->fsf_req = NULL;
	}
out:
	spin_unlock(&adapter->req_q.lock);
	return retval;
L
Linus Torvalds 已提交
1975 1976
}

1977 1978 1979
static void zfcp_fsf_update_lat(struct fsf_latency_record *lat_rec, u32 lat)
{
	lat_rec->sum += lat;
S
Swen Schillig 已提交
1980 1981
	lat_rec->min = min(lat_rec->min, lat);
	lat_rec->max = max(lat_rec->max, lat);
1982 1983
}

S
Swen Schillig 已提交
1984
static void zfcp_fsf_req_latency(struct zfcp_fsf_req *req)
1985 1986 1987
{
	struct fsf_qual_latency_info *lat_inf;
	struct latency_cont *lat;
S
Swen Schillig 已提交
1988
	struct zfcp_unit *unit = req->unit;
1989 1990
	unsigned long flags;

S
Swen Schillig 已提交
1991
	lat_inf = &req->qtcb->prefix.prot_status_qual.latency_info;
1992

S
Swen Schillig 已提交
1993
	switch (req->qtcb->bottom.io.data_direction) {
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
	case FSF_DATADIR_READ:
		lat = &unit->latencies.read;
		break;
	case FSF_DATADIR_WRITE:
		lat = &unit->latencies.write;
		break;
	case FSF_DATADIR_CMND:
		lat = &unit->latencies.cmd;
		break;
	default:
		return;
	}

	spin_lock_irqsave(&unit->latencies.lock, flags);
	zfcp_fsf_update_lat(&lat->channel, lat_inf->channel_lat);
	zfcp_fsf_update_lat(&lat->fabric, lat_inf->fabric_lat);
	lat->counter++;
S
Swen Schillig 已提交
2011
	spin_unlock_irqrestore(&unit->latencies.lock, flags);
L
Linus Torvalds 已提交
2012 2013
}

S
Swen Schillig 已提交
2014
static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
2015
{
S
Swen Schillig 已提交
2016
	struct scsi_cmnd *scpnt = req->data;
L
Linus Torvalds 已提交
2017
	struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
S
Swen Schillig 已提交
2018
	    &(req->qtcb->bottom.io.fcp_rsp);
L
Linus Torvalds 已提交
2019
	u32 sns_len;
2020
	char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
L
Linus Torvalds 已提交
2021 2022
	unsigned long flags;

C
Christof Schmitt 已提交
2023
	if (unlikely(!scpnt))
S
Swen Schillig 已提交
2024
		return;
C
Christof Schmitt 已提交
2025

S
Swen Schillig 已提交
2026 2027 2028
	read_lock_irqsave(&req->adapter->abort_lock, flags);

	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ABORTED)) {
2029 2030
		set_host_byte(scpnt, DID_SOFT_ERROR);
		set_driver_byte(scpnt, SUGGEST_RETRY);
L
Linus Torvalds 已提交
2031 2032 2033
		goto skip_fsfstatus;
	}

S
Swen Schillig 已提交
2034
	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
2035
		set_host_byte(scpnt, DID_ERROR);
L
Linus Torvalds 已提交
2036 2037 2038
		goto skip_fsfstatus;
	}

2039
	set_msg_byte(scpnt, COMMAND_COMPLETE);
L
Linus Torvalds 已提交
2040 2041 2042

	scpnt->result |= fcp_rsp_iu->scsi_status;

S
Swen Schillig 已提交
2043 2044
	if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)
		zfcp_fsf_req_latency(req);
2045

L
Linus Torvalds 已提交
2046
	if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) {
S
Swen Schillig 已提交
2047
		if (fcp_rsp_info[3] == RSP_CODE_GOOD)
2048
			set_host_byte(scpnt, DID_OK);
S
Swen Schillig 已提交
2049
		else {
2050
			set_host_byte(scpnt, DID_ERROR);
已提交
2051
			goto skip_fsfstatus;
L
Linus Torvalds 已提交
2052 2053 2054 2055
		}
	}

	if (unlikely(fcp_rsp_iu->validity.bits.fcp_sns_len_valid)) {
S
Swen Schillig 已提交
2056 2057
		sns_len = FSF_FCP_RSP_SIZE - sizeof(struct fcp_rsp_iu) +
			  fcp_rsp_iu->fcp_rsp_len;
L
Linus Torvalds 已提交
2058 2059 2060
		sns_len = min(sns_len, (u32) SCSI_SENSE_BUFFERSIZE);
		sns_len = min(sns_len, fcp_rsp_iu->fcp_sns_len);

2061
		memcpy(scpnt->sense_buffer,
L
Linus Torvalds 已提交
2062 2063 2064 2065
		       zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu), sns_len);
	}

	if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_under)) {
2066 2067 2068
		scsi_set_resid(scpnt, fcp_rsp_iu->fcp_resid);
		if (scsi_bufflen(scpnt) - scsi_get_resid(scpnt) <
		    scpnt->underflow)
2069
			set_host_byte(scpnt, DID_ERROR);
L
Linus Torvalds 已提交
2070
	}
S
Swen Schillig 已提交
2071
skip_fsfstatus:
2072
	if (scpnt->result != 0)
S
Swen Schillig 已提交
2073
		zfcp_scsi_dbf_event_result("erro", 3, req->adapter, scpnt, req);
2074
	else if (scpnt->retries > 0)
S
Swen Schillig 已提交
2075
		zfcp_scsi_dbf_event_result("retr", 4, req->adapter, scpnt, req);
2076
	else
S
Swen Schillig 已提交
2077
		zfcp_scsi_dbf_event_result("norm", 6, req->adapter, scpnt, req);
L
Linus Torvalds 已提交
2078 2079 2080 2081 2082 2083 2084 2085 2086

	scpnt->host_scribble = NULL;
	(scpnt->scsi_done) (scpnt);
	/*
	 * We must hold this lock until scsi_done has been called.
	 * Otherwise we may call scsi_done after abort regarding this
	 * command has completed.
	 * Note: scsi_done must not block!
	 */
S
Swen Schillig 已提交
2087
	read_unlock_irqrestore(&req->adapter->abort_lock, flags);
L
Linus Torvalds 已提交
2088 2089
}

S
Swen Schillig 已提交
2090
static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
2091 2092
{
	struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
S
Swen Schillig 已提交
2093
	    &(req->qtcb->bottom.io.fcp_rsp);
2094
	char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
L
Linus Torvalds 已提交
2095

S
Swen Schillig 已提交
2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
	if ((fcp_rsp_info[3] != RSP_CODE_GOOD) ||
	     (req->status & ZFCP_STATUS_FSFREQ_ERROR))
		req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
}


static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
{
	struct zfcp_unit *unit;
	struct fsf_qtcb_header *header = &req->qtcb->header;

	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT))
		unit = req->data;
	else
		unit = req->unit;

	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
L
Linus Torvalds 已提交
2113 2114
		goto skip_fsfstatus;

S
Swen Schillig 已提交
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124
	switch (header->fsf_status) {
	case FSF_HANDLE_MISMATCH:
	case FSF_PORT_HANDLE_NOT_VALID:
		zfcp_erp_adapter_reopen(unit->port->adapter, 0, 112, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
		break;
	case FSF_FCPLUN_NOT_VALID:
	case FSF_LUN_HANDLE_NOT_VALID:
		zfcp_erp_port_reopen(unit->port, 0, 113, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
2125
		break;
S
Swen Schillig 已提交
2126 2127
	case FSF_SERVICE_CLASS_NOT_SUPPORTED:
		zfcp_fsf_class_not_supp(req);
L
Linus Torvalds 已提交
2128
		break;
S
Swen Schillig 已提交
2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166
	case FSF_ACCESS_DENIED:
		zfcp_fsf_access_denied_unit(req, unit);
		break;
	case FSF_DIRECTION_INDICATOR_NOT_VALID:
		dev_err(&req->adapter->ccw_device->dev,
			"Invalid data direction (%d) given for unit "
			"0x%016Lx on port 0x%016Lx, shutting down "
			"adapter.\n",
			req->qtcb->bottom.io.data_direction,
			unit->fcp_lun, unit->port->wwpn);
		zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 133, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
		break;
	case FSF_CMND_LENGTH_NOT_VALID:
		dev_err(&req->adapter->ccw_device->dev,
			"An invalid control-data-block length field (%d) "
			"was found in a command for unit 0x%016Lx on port "
			"0x%016Lx. Shutting down adapter.\n",
			req->qtcb->bottom.io.fcp_cmnd_length,
			unit->fcp_lun, unit->port->wwpn);
		zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 134, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
		break;
	case FSF_PORT_BOXED:
		zfcp_erp_port_boxed(unit->port, 53, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
		break;
	case FSF_LUN_BOXED:
		zfcp_erp_unit_boxed(unit, 54, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		if (header->fsf_status_qual.word[0] ==
		    FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
			zfcp_test_link(unit->port);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
2167 2168
		break;
	}
S
Swen Schillig 已提交
2169 2170 2171 2172 2173 2174 2175 2176
skip_fsfstatus:
	if (req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
		zfcp_fsf_send_fcp_ctm_handler(req);
	else {
		zfcp_fsf_send_fcp_command_task_handler(req);
		req->unit = NULL;
		zfcp_unit_put(unit);
	}
L
Linus Torvalds 已提交
2177 2178
}

S
Swen Schillig 已提交
2179 2180 2181 2182 2183 2184 2185
/**
 * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
 * @adapter: adapter where scsi command is issued
 * @unit: unit where command is sent to
 * @scsi_cmnd: scsi command to be sent
 * @timer: timer to be started when request is initiated
 * @req_flags: flags for fsf_request
L
Linus Torvalds 已提交
2186
 */
S
Swen Schillig 已提交
2187 2188 2189 2190
int zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *adapter,
				   struct zfcp_unit *unit,
				   struct scsi_cmnd *scsi_cmnd,
				   int use_timer, int req_flags)
L
Linus Torvalds 已提交
2191
{
S
Swen Schillig 已提交
2192 2193 2194 2195
	struct zfcp_fsf_req *req;
	struct fcp_cmnd_iu *fcp_cmnd_iu;
	unsigned int sbtype;
	int real_bytes, retval = -EIO;
L
Linus Torvalds 已提交
2196

S
Swen Schillig 已提交
2197 2198 2199
	if (unlikely(!(atomic_read(&unit->status) &
		       ZFCP_STATUS_COMMON_UNBLOCKED)))
		return -EBUSY;
L
Linus Torvalds 已提交
2200

S
Swen Schillig 已提交
2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
	spin_lock(&adapter->req_q.lock);
	if (!atomic_read(&adapter->req_q.count))
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
				  adapter->pool.fsf_req_scsi);
	if (unlikely(IS_ERR(req))) {
		retval = PTR_ERR(req);
		goto out;
	}

	zfcp_unit_get(unit);
	req->unit = unit;
	req->data = scsi_cmnd;
	req->handler = zfcp_fsf_send_fcp_command_handler;
	req->qtcb->header.lun_handle = unit->handle;
	req->qtcb->header.port_handle = unit->port->handle;
	req->qtcb->bottom.io.service_class = FSF_CLASS_3;

	scsi_cmnd->host_scribble = (unsigned char *) req->req_id;

	fcp_cmnd_iu = (struct fcp_cmnd_iu *) &(req->qtcb->bottom.io.fcp_cmnd);
	fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
	/*
	 * set depending on data direction:
	 *      data direction bits in SBALE (SB Type)
	 *      data direction bits in QTCB
	 *      data direction bits in FCP_CMND IU
	 */
	switch (scsi_cmnd->sc_data_direction) {
	case DMA_NONE:
		req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
		sbtype = SBAL_FLAGS0_TYPE_READ;
L
Linus Torvalds 已提交
2233
		break;
S
Swen Schillig 已提交
2234 2235 2236 2237 2238 2239 2240 2241 2242
	case DMA_FROM_DEVICE:
		req->qtcb->bottom.io.data_direction = FSF_DATADIR_READ;
		sbtype = SBAL_FLAGS0_TYPE_READ;
		fcp_cmnd_iu->rddata = 1;
		break;
	case DMA_TO_DEVICE:
		req->qtcb->bottom.io.data_direction = FSF_DATADIR_WRITE;
		sbtype = SBAL_FLAGS0_TYPE_WRITE;
		fcp_cmnd_iu->wddata = 1;
L
Linus Torvalds 已提交
2243
		break;
S
Swen Schillig 已提交
2244
	case DMA_BIDIRECTIONAL:
L
Linus Torvalds 已提交
2245
	default:
S
Swen Schillig 已提交
2246 2247
		retval = -EIO;
		goto failed_scsi_cmnd;
L
Linus Torvalds 已提交
2248 2249
	}

S
Swen Schillig 已提交
2250 2251 2252 2253 2254 2255
	if (likely((scsi_cmnd->device->simple_tags) ||
		   ((atomic_read(&unit->status) & ZFCP_STATUS_UNIT_READONLY) &&
		    (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_SHARED))))
		fcp_cmnd_iu->task_attribute = SIMPLE_Q;
	else
		fcp_cmnd_iu->task_attribute = UNTAGGED;
L
Linus Torvalds 已提交
2256

S
Swen Schillig 已提交
2257 2258 2259
	if (unlikely(scsi_cmnd->cmd_len > FCP_CDB_LENGTH))
		fcp_cmnd_iu->add_fcp_cdb_length =
			(scsi_cmnd->cmd_len - FCP_CDB_LENGTH) >> 2;
L
Linus Torvalds 已提交
2260

S
Swen Schillig 已提交
2261
	memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
2262

S
Swen Schillig 已提交
2263 2264
	req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
		fcp_cmnd_iu->add_fcp_cdb_length + sizeof(fcp_dl_t);
L
Linus Torvalds 已提交
2265

S
Swen Schillig 已提交
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
	real_bytes = zfcp_qdio_sbals_from_sg(req, sbtype,
					     scsi_sglist(scsi_cmnd),
					     FSF_MAX_SBALS_PER_REQ);
	if (unlikely(real_bytes < 0)) {
		if (req->sbal_number < FSF_MAX_SBALS_PER_REQ)
			retval = -EIO;
		else {
			dev_err(&adapter->ccw_device->dev,
				"SCSI request too large. "
				"Shutting down unit 0x%016Lx on port "
				"0x%016Lx.\n", unit->fcp_lun,
				unit->port->wwpn);
			zfcp_erp_unit_shutdown(unit, 0, 131, req);
			retval = -EINVAL;
		}
		goto failed_scsi_cmnd;
L
Linus Torvalds 已提交
2282 2283
	}

S
Swen Schillig 已提交
2284
	zfcp_set_fcp_dl(fcp_cmnd_iu, real_bytes);
L
Linus Torvalds 已提交
2285

S
Swen Schillig 已提交
2286 2287
	if (use_timer)
		zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
L
Linus Torvalds 已提交
2288

S
Swen Schillig 已提交
2289 2290 2291
	retval = zfcp_fsf_req_send(req);
	if (unlikely(retval))
		goto failed_scsi_cmnd;
L
Linus Torvalds 已提交
2292

S
Swen Schillig 已提交
2293
	goto out;
L
Linus Torvalds 已提交
2294

S
Swen Schillig 已提交
2295 2296 2297 2298 2299 2300 2301
failed_scsi_cmnd:
	zfcp_unit_put(unit);
	zfcp_fsf_req_free(req);
	scsi_cmnd->host_scribble = NULL;
out:
	spin_unlock(&adapter->req_q.lock);
	return retval;
L
Linus Torvalds 已提交
2302 2303 2304
}

/**
S
Swen Schillig 已提交
2305 2306 2307 2308 2309 2310
 * zfcp_fsf_send_fcp_ctm - send SCSI task management command
 * @adapter: pointer to struct zfcp-adapter
 * @unit: pointer to struct zfcp_unit
 * @tm_flags: unsigned byte for task management flags
 * @req_flags: int request flags
 * Returns: on success pointer to struct fsf_req, NULL otherwise
L
Linus Torvalds 已提交
2311
 */
S
Swen Schillig 已提交
2312 2313 2314
struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_adapter *adapter,
					   struct zfcp_unit *unit,
					   u8 tm_flags, int req_flags)
L
Linus Torvalds 已提交
2315 2316
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
2317 2318
	struct zfcp_fsf_req *req = NULL;
	struct fcp_cmnd_iu *fcp_cmnd_iu;
L
Linus Torvalds 已提交
2319

S
Swen Schillig 已提交
2320 2321 2322
	if (unlikely(!(atomic_read(&unit->status) &
		       ZFCP_STATUS_COMMON_UNBLOCKED)))
		return NULL;
L
Linus Torvalds 已提交
2323

S
Swen Schillig 已提交
2324 2325 2326 2327 2328 2329 2330
	spin_lock(&adapter->req_q.lock);
	if (!atomic_read(&adapter->req_q.count))
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
				  adapter->pool.fsf_req_scsi);
	if (unlikely(IS_ERR(req)))
		goto out;
L
Linus Torvalds 已提交
2331

S
Swen Schillig 已提交
2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
	req->status |= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT;
	req->data = unit;
	req->handler = zfcp_fsf_send_fcp_command_handler;
	req->qtcb->header.lun_handle = unit->handle;
	req->qtcb->header.port_handle = unit->port->handle;
	req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
	req->qtcb->bottom.io.service_class = FSF_CLASS_3;
	req->qtcb->bottom.io.fcp_cmnd_length = 	sizeof(struct fcp_cmnd_iu) +
						sizeof(fcp_dl_t);

	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
2345

S
Swen Schillig 已提交
2346 2347 2348
	fcp_cmnd_iu = (struct fcp_cmnd_iu *) &req->qtcb->bottom.io.fcp_cmnd;
	fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
	fcp_cmnd_iu->task_management_flags = tm_flags;
L
Linus Torvalds 已提交
2349

S
Swen Schillig 已提交
2350 2351 2352
	zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
	if (!zfcp_fsf_req_send(req))
		goto out;
L
Linus Torvalds 已提交
2353

S
Swen Schillig 已提交
2354 2355 2356 2357 2358 2359
	zfcp_fsf_req_free(req);
	req = NULL;
out:
	spin_unlock(&adapter->req_q.lock);
	return req;
}
L
Linus Torvalds 已提交
2360

S
Swen Schillig 已提交
2361 2362 2363 2364
static void zfcp_fsf_control_file_handler(struct zfcp_fsf_req *req)
{
	if (req->qtcb->header.fsf_status != FSF_GOOD)
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
2365 2366
}

S
Swen Schillig 已提交
2367 2368 2369 2370 2371
/**
 * zfcp_fsf_control_file - control file upload/download
 * @adapter: pointer to struct zfcp_adapter
 * @fsf_cfdc: pointer to struct zfcp_fsf_cfdc
 * Returns: on success pointer to struct zfcp_fsf_req, NULL otherwise
L
Linus Torvalds 已提交
2372
 */
S
Swen Schillig 已提交
2373 2374
struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
					   struct zfcp_fsf_cfdc *fsf_cfdc)
L
Linus Torvalds 已提交
2375 2376
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393
	struct zfcp_fsf_req *req = NULL;
	struct fsf_qtcb_bottom_support *bottom;
	int direction, retval = -EIO, bytes;

	if (!(adapter->adapter_features & FSF_FEATURE_CFDC))
		return ERR_PTR(-EOPNOTSUPP);

	switch (fsf_cfdc->command) {
	case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
		direction = SBAL_FLAGS0_TYPE_WRITE;
		break;
	case FSF_QTCB_UPLOAD_CONTROL_FILE:
		direction = SBAL_FLAGS0_TYPE_READ;
		break;
	default:
		return ERR_PTR(-EINVAL);
	}
L
Linus Torvalds 已提交
2394

S
Swen Schillig 已提交
2395 2396 2397
	spin_lock(&adapter->req_q.lock);
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;
L
Linus Torvalds 已提交
2398

S
Swen Schillig 已提交
2399 2400 2401 2402 2403
	req = zfcp_fsf_req_create(adapter, fsf_cfdc->command, 0, NULL);
	if (unlikely(IS_ERR(req))) {
		retval = -EPERM;
		goto out;
	}
L
Linus Torvalds 已提交
2404

S
Swen Schillig 已提交
2405
	req->handler = zfcp_fsf_control_file_handler;
L
Linus Torvalds 已提交
2406

S
Swen Schillig 已提交
2407 2408
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= direction;
2409

S
Swen Schillig 已提交
2410 2411 2412
	bottom = &req->qtcb->bottom.support;
	bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
	bottom->option = fsf_cfdc->option;
2413

S
Swen Schillig 已提交
2414 2415 2416 2417 2418 2419 2420
	bytes = zfcp_qdio_sbals_from_sg(req, direction, fsf_cfdc->sg,
					FSF_MAX_SBALS_PER_REQ);
	if (bytes != ZFCP_CFDC_MAX_SIZE) {
		retval = -ENOMEM;
		zfcp_fsf_req_free(req);
		goto out;
	}
L
Linus Torvalds 已提交
2421

S
Swen Schillig 已提交
2422 2423 2424 2425
	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	retval = zfcp_fsf_req_send(req);
out:
	spin_unlock(&adapter->req_q.lock);
2426

S
Swen Schillig 已提交
2427 2428 2429 2430
	if (!retval) {
		wait_event(req->completion_wq,
			   req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
		return req;
L
Linus Torvalds 已提交
2431
	}
S
Swen Schillig 已提交
2432
	return ERR_PTR(retval);
L
Linus Torvalds 已提交
2433
}