zfcp_fsf.c 71.8 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
#define KMSG_COMPONENT "zfcp"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

S
Stefan Raspl 已提交
12
#include <linux/blktrace_api.h>
L
Linus Torvalds 已提交
13 14
#include "zfcp_ext.h"

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
static void zfcp_fsf_request_timeout_handler(unsigned long data)
{
	struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 62,
				NULL);
}

static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
				 unsigned long timeout)
{
	fsf_req->timer.function = zfcp_fsf_request_timeout_handler;
	fsf_req->timer.data = (unsigned long) fsf_req->adapter;
	fsf_req->timer.expires = jiffies + timeout;
	add_timer(&fsf_req->timer);
}

static void zfcp_fsf_start_erp_timer(struct zfcp_fsf_req *fsf_req)
{
	BUG_ON(!fsf_req->erp_action);
	fsf_req->timer.function = zfcp_erp_timeout_handler;
	fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
	fsf_req->timer.expires = jiffies + 30 * HZ;
	add_timer(&fsf_req->timer);
}

L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
/* 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
};

C
Christof Schmitt 已提交
57 58
static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
{
S
Swen Schillig 已提交
59
	u16 subtable = table >> 16;
C
Christof Schmitt 已提交
60
	u16 rule = table & 0xffff;
61
	const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" };
C
Christof Schmitt 已提交
62

63
	if (subtable && subtable < ARRAY_SIZE(act_type))
C
Christof Schmitt 已提交
64
		dev_warn(&adapter->ccw_device->dev,
65 66
			 "Access denied according to ACT rule type %s, "
			 "rule %d\n", act_type[subtable], rule);
C
Christof Schmitt 已提交
67 68 69 70 71 72 73
}

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,
74
		 "Access denied to port 0x%016Lx\n",
75
		 (unsigned long long)port->wwpn);
C
Christof Schmitt 已提交
76 77 78 79 80 81 82 83 84 85 86
	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,
87
		 "Access denied to unit 0x%016Lx on port 0x%016Lx\n",
88 89
		 (unsigned long long)unit->fcp_lun,
		 (unsigned long long)unit->port->wwpn);
C
Christof Schmitt 已提交
90 91 92 93 94 95 96 97
	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)
{
98 99
	dev_err(&req->adapter->ccw_device->dev, "FCP device not "
		"operational because of an unsupported FC class\n");
C
Christof Schmitt 已提交
100 101 102 103
	zfcp_erp_adapter_shutdown(req->adapter, 0, 123, req);
	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
}

S
Swen Schillig 已提交
104 105 106
/**
 * zfcp_fsf_req_free - free memory used by fsf request
 * @fsf_req: pointer to struct zfcp_fsf_req
L
Linus Torvalds 已提交
107
 */
S
Swen Schillig 已提交
108
void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
109
{
S
Swen Schillig 已提交
110 111
	if (likely(req->pool)) {
		mempool_free(req, req->pool);
112 113 114
		return;
	}

S
Swen Schillig 已提交
115 116
	if (req->qtcb) {
		kmem_cache_free(zfcp_data.fsf_req_qtcb_cache, req);
117 118
		return;
	}
L
Linus Torvalds 已提交
119 120
}

S
Swen Schillig 已提交
121 122 123 124
/**
 * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
 * @adapter: pointer to struct zfcp_adapter
 *
125 126 127 128
 * 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 已提交
129
 */
130
void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
131
{
S
Swen Schillig 已提交
132
	struct zfcp_fsf_req *req, *tmp;
133
	unsigned long flags;
134
	LIST_HEAD(remove_queue);
135
	unsigned int i;
136

S
Swen Schillig 已提交
137
	BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
138
	spin_lock_irqsave(&adapter->req_list_lock, flags);
139
	for (i = 0; i < REQUEST_LIST_SIZE; i++)
140
		list_splice_init(&adapter->req_list[i], &remove_queue);
141 142
	spin_unlock_irqrestore(&adapter->req_list_lock, flags);

S
Swen Schillig 已提交
143 144 145 146
	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 已提交
147 148 149
	}
}

S
Swen Schillig 已提交
150
static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
151
{
S
Swen Schillig 已提交
152 153 154 155 156
	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 已提交
157

S
Swen Schillig 已提交
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
	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 已提交
173 174
}

S
Swen Schillig 已提交
175 176
static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, u8 id,
					 struct fsf_link_down_info *link_down)
177
{
S
Swen Schillig 已提交
178
	struct zfcp_adapter *adapter = req->adapter;
179

S
Swen Schillig 已提交
180
	if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
181 182 183 184
		return;

	atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);

S
Swen Schillig 已提交
185
	if (!link_down)
186
		goto out;
187

188 189
	switch (link_down->error_code) {
	case FSF_PSQ_LINK_NO_LIGHT:
S
Swen Schillig 已提交
190
		dev_warn(&req->adapter->ccw_device->dev,
191 192
			 "There is no light signal from the local "
			 "fibre channel cable\n");
193 194
		break;
	case FSF_PSQ_LINK_WRAP_PLUG:
S
Swen Schillig 已提交
195
		dev_warn(&req->adapter->ccw_device->dev,
196 197
			 "There is a wrap plug instead of a fibre "
			 "channel cable\n");
198 199
		break;
	case FSF_PSQ_LINK_NO_FCP:
S
Swen Schillig 已提交
200
		dev_warn(&req->adapter->ccw_device->dev,
201 202
			 "The adjacent fibre channel node does not "
			 "support FCP\n");
203 204
		break;
	case FSF_PSQ_LINK_FIRMWARE_UPDATE:
S
Swen Schillig 已提交
205
		dev_warn(&req->adapter->ccw_device->dev,
206 207
			 "The FCP device is suspended because of a "
			 "firmware update\n");
C
Christof Schmitt 已提交
208
		break;
209
	case FSF_PSQ_LINK_INVALID_WWPN:
S
Swen Schillig 已提交
210
		dev_warn(&req->adapter->ccw_device->dev,
211 212
			 "The FCP device detected a WWPN that is "
			 "duplicate or not valid\n");
213 214
		break;
	case FSF_PSQ_LINK_NO_NPIV_SUPPORT:
S
Swen Schillig 已提交
215
		dev_warn(&req->adapter->ccw_device->dev,
216
			 "The fibre channel fabric does not support NPIV\n");
217 218
		break;
	case FSF_PSQ_LINK_NO_FCP_RESOURCES:
S
Swen Schillig 已提交
219
		dev_warn(&req->adapter->ccw_device->dev,
220
			 "The FCP adapter cannot support more NPIV ports\n");
221 222
		break;
	case FSF_PSQ_LINK_NO_FABRIC_RESOURCES:
S
Swen Schillig 已提交
223
		dev_warn(&req->adapter->ccw_device->dev,
224 225
			 "The adjacent switch cannot support "
			 "more NPIV ports\n");
226 227
		break;
	case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE:
S
Swen Schillig 已提交
228
		dev_warn(&req->adapter->ccw_device->dev,
229 230
			 "The FCP adapter could not log in to the "
			 "fibre channel fabric\n");
231 232
		break;
	case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED:
S
Swen Schillig 已提交
233
		dev_warn(&req->adapter->ccw_device->dev,
234 235
			 "The WWPN assignment file on the FCP adapter "
			 "has been damaged\n");
236 237
		break;
	case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED:
S
Swen Schillig 已提交
238
		dev_warn(&req->adapter->ccw_device->dev,
239 240
			 "The mode table on the FCP adapter "
			 "has been damaged\n");
241 242
		break;
	case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT:
S
Swen Schillig 已提交
243
		dev_warn(&req->adapter->ccw_device->dev,
244 245
			 "All NPIV ports on the FCP adapter have "
			 "been assigned\n");
246 247
		break;
	default:
S
Swen Schillig 已提交
248
		dev_warn(&req->adapter->ccw_device->dev,
249 250
			 "The link between the FCP adapter and "
			 "the FC fabric is down\n");
251
	}
S
Swen Schillig 已提交
252 253
out:
	zfcp_erp_adapter_failed(adapter, id, req);
254 255
}

S
Swen Schillig 已提交
256
static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
257
{
S
Swen Schillig 已提交
258 259 260
	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 已提交
261

S
Swen Schillig 已提交
262 263 264
	switch (sr_buf->status_subtype) {
	case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
		zfcp_fsf_link_down_info_eval(req, 38, ldi);
L
Linus Torvalds 已提交
265
		break;
S
Swen Schillig 已提交
266 267
	case FSF_STATUS_READ_SUB_FDISC_FAILED:
		zfcp_fsf_link_down_info_eval(req, 39, ldi);
L
Linus Torvalds 已提交
268
		break;
S
Swen Schillig 已提交
269 270 271 272
	case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
		zfcp_fsf_link_down_info_eval(req, 40, NULL);
	};
}
L
Linus Torvalds 已提交
273

S
Swen Schillig 已提交
274 275 276 277
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 已提交
278

S
Swen Schillig 已提交
279 280 281 282 283 284
	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 已提交
285

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

S
Swen Schillig 已提交
288 289 290
	switch (sr_buf->status_type) {
	case FSF_STATUS_READ_PORT_CLOSED:
		zfcp_fsf_status_read_port_closed(req);
L
Linus Torvalds 已提交
291
		break;
S
Swen Schillig 已提交
292 293
	case FSF_STATUS_READ_INCOMING_ELS:
		zfcp_fc_incoming_els(req);
L
Linus Torvalds 已提交
294
		break;
S
Swen Schillig 已提交
295
	case FSF_STATUS_READ_SENSE_DATA_AVAIL:
L
Linus Torvalds 已提交
296
		break;
S
Swen Schillig 已提交
297
	case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
298 299 300
		dev_warn(&adapter->ccw_device->dev,
			 "The error threshold for checksum statistics "
			 "has been exceeded\n");
301
		zfcp_hba_dbf_event_berr(adapter, req);
L
Linus Torvalds 已提交
302
		break;
S
Swen Schillig 已提交
303 304 305 306 307
	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,
308
			 "The local link has been restored\n");
S
Swen Schillig 已提交
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
		/* 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 已提交
329 330 331
		break;
	}

S
Swen Schillig 已提交
332 333
	mempool_free(sr_buf, adapter->pool.data_status_read);
	zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
334

S
Swen Schillig 已提交
335
	atomic_inc(&adapter->stat_miss);
336
	queue_work(zfcp_data.work_queue, &adapter->stat_work);
S
Swen Schillig 已提交
337
}
L
Linus Torvalds 已提交
338

S
Swen Schillig 已提交
339 340 341 342 343 344 345 346 347 348 349 350 351
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,
352 353
			"The FCP adapter reported a problem "
			"that cannot be recovered\n");
S
Swen Schillig 已提交
354 355 356 357 358
		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 已提交
359 360
}

S
Swen Schillig 已提交
361
static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
362
{
S
Swen Schillig 已提交
363 364
	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
		return;
L
Linus Torvalds 已提交
365

S
Swen Schillig 已提交
366 367 368
	switch (req->qtcb->header.fsf_status) {
	case FSF_UNKNOWN_COMMAND:
		dev_err(&req->adapter->ccw_device->dev,
369
			"The FCP adapter does not recognize the command 0x%x\n",
S
Swen Schillig 已提交
370 371 372 373 374 375 376 377 378
			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 已提交
379

S
Swen Schillig 已提交
380 381 382 383 384
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 已提交
385

S
Swen Schillig 已提交
386
	zfcp_hba_dbf_event_fsf_response(req);
L
Linus Torvalds 已提交
387

S
Swen Schillig 已提交
388 389 390 391 392
	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 已提交
393

S
Swen Schillig 已提交
394 395 396 397 398 399
	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,
400 401 402
			"QTCB version 0x%x not supported by FCP adapter "
			"(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
			psq->word[0], psq->word[1]);
S
Swen Schillig 已提交
403 404 405 406 407 408 409 410 411
		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,
412
			"The QTCB type is not supported by the FCP adapter\n");
S
Swen Schillig 已提交
413 414 415 416 417 418 419 420
		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,
421
			"0x%Lx is an ambiguous request identifier\n",
S
Swen Schillig 已提交
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
			(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,
441
			"0x%x is not a valid transfer protocol status\n",
S
Swen Schillig 已提交
442 443 444 445
			qtcb->prefix.prot_status);
		zfcp_erp_adapter_shutdown(adapter, 0, 119, req);
	}
	req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
446 447
}

S
Swen Schillig 已提交
448 449 450 451 452 453 454 455 456 457
/**
 * 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 已提交
458
{
S
Swen Schillig 已提交
459 460 461 462
	if (unlikely(req->fsf_command == FSF_QTCB_UNSOLICITED_STATUS)) {
		zfcp_fsf_status_read_handler(req);
		return;
	}
L
Linus Torvalds 已提交
463

S
Swen Schillig 已提交
464 465 466 467
	del_timer(&req->timer);
	zfcp_fsf_protstatus_eval(req);
	zfcp_fsf_fsfstatus_eval(req);
	req->handler(req);
L
Linus Torvalds 已提交
468

S
Swen Schillig 已提交
469
	if (req->erp_action)
470
		zfcp_erp_notify(req->erp_action, 0);
S
Swen Schillig 已提交
471
	req->status |= ZFCP_STATUS_FSFREQ_COMPLETED;
L
Linus Torvalds 已提交
472

S
Swen Schillig 已提交
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
	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 已提交
489

S
Swen Schillig 已提交
490 491 492 493 494
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 已提交
495

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

S
Swen Schillig 已提交
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
	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;
		break;
	case FSF_TOPO_FABRIC:
		fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
		break;
	case FSF_TOPO_AL:
		fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
	default:
		dev_err(&adapter->ccw_device->dev,
527 528 529
			"Unknown or unsupported arbitrated loop "
			"fibre channel topology detected\n");
		zfcp_erp_adapter_shutdown(adapter, 0, 127, req);
S
Swen Schillig 已提交
530
		return -EIO;
L
Linus Torvalds 已提交
531
	}
S
Swen Schillig 已提交
532

L
Linus Torvalds 已提交
533 534 535
	return 0;
}

S
Swen Schillig 已提交
536
static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
C
Christof Schmitt 已提交
537 538
{
	struct zfcp_adapter *adapter = req->adapter;
S
Swen Schillig 已提交
539 540 541
	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 已提交
542

S
Swen Schillig 已提交
543 544
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
		return;
L
Linus Torvalds 已提交
545

S
Swen Schillig 已提交
546 547 548 549 550 551
	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;
552

S
Swen Schillig 已提交
553 554 555 556
	switch (qtcb->header.fsf_status) {
	case FSF_GOOD:
		if (zfcp_fsf_exchange_config_evaluate(req))
			return;
L
Linus Torvalds 已提交
557

S
Swen Schillig 已提交
558 559
		if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
			dev_err(&adapter->ccw_device->dev,
560 561 562
				"FCP adapter maximum QTCB size (%d bytes) "
				"is too small\n",
				bottom->max_qtcb_size);
S
Swen Schillig 已提交
563 564 565 566 567
			zfcp_erp_adapter_shutdown(adapter, 0, 129, req);
			return;
		}
		atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
				&adapter->status);
L
Linus Torvalds 已提交
568
		break;
S
Swen Schillig 已提交
569 570 571 572 573 574 575
	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 已提交
576

S
Swen Schillig 已提交
577 578
		atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
				&adapter->status);
L
Linus Torvalds 已提交
579

S
Swen Schillig 已提交
580 581
		zfcp_fsf_link_down_info_eval(req, 42,
			&qtcb->header.fsf_status_qual.link_down_info);
L
Linus Torvalds 已提交
582
		break;
S
Swen Schillig 已提交
583 584 585 586
	default:
		zfcp_erp_adapter_shutdown(adapter, 0, 130, req);
		return;
	}
L
Linus Torvalds 已提交
587

S
Swen Schillig 已提交
588 589 590 591 592 593 594
	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 已提交
595

S
Swen Schillig 已提交
596 597
	if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) {
		dev_err(&adapter->ccw_device->dev,
598 599
			"The FCP adapter only supports newer "
			"control block versions\n");
S
Swen Schillig 已提交
600 601 602 603 604
		zfcp_erp_adapter_shutdown(adapter, 0, 125, req);
		return;
	}
	if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
		dev_err(&adapter->ccw_device->dev,
605 606
			"The FCP adapter only supports older "
			"control block versions\n");
S
Swen Schillig 已提交
607 608 609
		zfcp_erp_adapter_shutdown(adapter, 0, 126, req);
	}
}
L
Linus Torvalds 已提交
610

S
Swen Schillig 已提交
611 612 613 614 615
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 已提交
616

S
Swen Schillig 已提交
617 618
	if (req->data)
		memcpy(req->data, bottom, sizeof(*bottom));
619

S
Swen Schillig 已提交
620 621 622 623 624 625 626
	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 已提交
627

S
Swen Schillig 已提交
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
{
	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);
		break;
	case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
		zfcp_fsf_exchange_port_evaluate(req);
		zfcp_fsf_link_down_info_eval(req, 43,
			&qtcb->header.fsf_status_qual.link_down_info);
643
		break;
L
Linus Torvalds 已提交
644
	}
S
Swen Schillig 已提交
645
}
646

647
static int zfcp_fsf_sbal_available(struct zfcp_adapter *adapter)
S
Swen Schillig 已提交
648
{
649
	if (atomic_read(&adapter->req_q.count) > 0)
S
Swen Schillig 已提交
650
		return 1;
651
	atomic_inc(&adapter->qdio_outb_full);
S
Swen Schillig 已提交
652
	return 0;
L
Linus Torvalds 已提交
653 654
}

S
Swen Schillig 已提交
655
static int zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter)
656 657
	__releases(&adapter->req_q_lock)
	__acquires(&adapter->req_q_lock)
S
Swen Schillig 已提交
658
{
659
	struct zfcp_qdio_queue *req_q = &adapter->req_q;
S
Swen Schillig 已提交
660 661
	long ret;

662 663 664 665 666 667
	if (atomic_read(&req_q->count) <= -REQUEST_LIST_SIZE)
		return -EIO;
	if (atomic_read(&req_q->count) > 0)
		return 0;

	atomic_dec(&req_q->count);
668
	spin_unlock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
669
	ret = wait_event_interruptible_timeout(adapter->request_wq,
670 671 672 673 674
					atomic_read(&req_q->count) >= 0,
					5 * HZ);
	spin_lock_bh(&adapter->req_q_lock);
	atomic_inc(&req_q->count);

S
Swen Schillig 已提交
675 676
	if (ret > 0)
		return 0;
677 678
	if (!ret)
		atomic_inc(&adapter->qdio_outb_full);
S
Swen Schillig 已提交
679 680 681 682 683 684 685 686 687 688
	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));
689
	req->pool = pool;
S
Swen Schillig 已提交
690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
	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 已提交
715
{
716
	struct qdio_buffer_element *sbale;
L
Linus Torvalds 已提交
717

S
Swen Schillig 已提交
718 719
	struct zfcp_fsf_req *req;
	struct zfcp_qdio_queue *req_q = &adapter->req_q;
720

S
Swen Schillig 已提交
721 722 723 724
	if (req_flags & ZFCP_REQ_NO_QTCB)
		req = zfcp_fsf_alloc_noqtcb(pool);
	else
		req = zfcp_fsf_alloc_qtcb(pool);
L
Linus Torvalds 已提交
725

S
Swen Schillig 已提交
726 727
	if (unlikely(!req))
		return ERR_PTR(-EIO);
L
Linus Torvalds 已提交
728

S
Swen Schillig 已提交
729 730
	if (adapter->req_no == 0)
		adapter->req_no++;
L
Linus Torvalds 已提交
731

S
Swen Schillig 已提交
732 733 734
	INIT_LIST_HEAD(&req->list);
	init_timer(&req->timer);
	init_waitqueue_head(&req->completion_wq);
L
Linus Torvalds 已提交
735

S
Swen Schillig 已提交
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
	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);
	}
766

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

S
Swen Schillig 已提交
770
	return req;
L
Linus Torvalds 已提交
771 772
}

S
Swen Schillig 已提交
773 774 775
static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
{
	struct zfcp_adapter *adapter = req->adapter;
776
	unsigned long flags;
S
Swen Schillig 已提交
777 778 779
	int idx;

	/* put allocated FSF request into hash table */
780
	spin_lock_irqsave(&adapter->req_list_lock, flags);
S
Swen Schillig 已提交
781 782
	idx = zfcp_reqlist_hash(req->req_id);
	list_add_tail(&req->list, &adapter->req_list[idx]);
783
	spin_unlock_irqrestore(&adapter->req_list_lock, flags);
S
Swen Schillig 已提交
784

785
	req->qdio_outb_usage = atomic_read(&adapter->req_q.count);
S
Swen Schillig 已提交
786 787 788
	req->issued = get_clock();
	if (zfcp_qdio_send(req)) {
		del_timer(&req->timer);
789 790 791 792 793
		spin_lock_irqsave(&adapter->req_list_lock, flags);
		/* lookup request again, list might have changed */
		if (zfcp_reqlist_find_safe(adapter, req))
			zfcp_reqlist_remove(adapter, req);
		spin_unlock_irqrestore(&adapter->req_list_lock, flags);
S
Swen Schillig 已提交
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
		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 已提交
810
 */
S
Swen Schillig 已提交
811
int zfcp_fsf_status_read(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
812
{
S
Swen Schillig 已提交
813 814
	struct zfcp_fsf_req *req;
	struct fsf_status_read_buffer *sr_buf;
815
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
816
	int retval = -EIO;
L
Linus Torvalds 已提交
817

818
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
819 820 821 822 823 824
	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);
825
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
826 827
		retval = PTR_ERR(req);
		goto out;
L
Linus Torvalds 已提交
828 829
	}

S
Swen Schillig 已提交
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
	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);
845

S
Swen Schillig 已提交
846 847 848
	retval = zfcp_fsf_req_send(req);
	if (retval)
		goto failed_req_send;
L
Linus Torvalds 已提交
849

S
Swen Schillig 已提交
850 851 852 853 854 855 856 857
	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:
858
	spin_unlock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
859 860 861 862 863 864 865 866 867 868 869 870
	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 已提交
871
	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
872
		if (fsq->word[0] == fsq->word[1]) {
873
			zfcp_erp_adapter_reopen(unit->port->adapter, 0, 104,
S
Swen Schillig 已提交
874 875
						req);
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
876 877 878
		}
		break;
	case FSF_LUN_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
879 880 881
		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 已提交
882 883 884
		}
		break;
	case FSF_FCP_COMMAND_DOES_NOT_EXIST:
S
Swen Schillig 已提交
885
		req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
L
Linus Torvalds 已提交
886 887
		break;
	case FSF_PORT_BOXED:
S
Swen Schillig 已提交
888 889 890
		zfcp_erp_port_boxed(unit->port, 47, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
891 892
		break;
	case FSF_LUN_BOXED:
S
Swen Schillig 已提交
893 894 895
		zfcp_erp_unit_boxed(unit, 48, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
896 897
                break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
S
Swen Schillig 已提交
898
		switch (fsq->word[0]) {
L
Linus Torvalds 已提交
899
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
900
			zfcp_test_link(unit->port);
L
Linus Torvalds 已提交
901
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
902
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
903 904 905 906
			break;
		}
		break;
	case FSF_GOOD:
S
Swen Schillig 已提交
907
		req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED;
L
Linus Torvalds 已提交
908 909 910 911 912
		break;
	}
}

/**
S
Swen Schillig 已提交
913 914 915 916 917 918 919 920
 * 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 已提交
921 922
 */

S
Swen Schillig 已提交
923 924 925 926
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 已提交
927
{
928
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
929
	struct zfcp_fsf_req *req = NULL;
930

931
	spin_lock(&adapter->req_q_lock);
932
	if (!zfcp_fsf_sbal_available(adapter))
S
Swen Schillig 已提交
933 934 935
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND,
				  req_flags, adapter->pool.fsf_req_abort);
936 937
	if (IS_ERR(req)) {
		req = NULL;
S
Swen Schillig 已提交
938
		goto out;
939
	}
940

S
Swen Schillig 已提交
941 942 943
	if (unlikely(!(atomic_read(&unit->status) &
		       ZFCP_STATUS_COMMON_UNBLOCKED)))
		goto out_error_free;
L
Linus Torvalds 已提交
944

S
Swen Schillig 已提交
945 946 947
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
948

S
Swen Schillig 已提交
949 950 951 952 953 954 955 956 957 958 959 960 961 962
	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:
963
	spin_unlock(&adapter->req_q_lock);
S
Swen Schillig 已提交
964
	return req;
L
Linus Torvalds 已提交
965 966
}

S
Swen Schillig 已提交
967
static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
968
{
S
Swen Schillig 已提交
969 970 971
	struct zfcp_adapter *adapter = req->adapter;
	struct zfcp_send_ct *send_ct = req->data;
	struct fsf_qtcb_header *header = &req->qtcb->header;
L
Linus Torvalds 已提交
972

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

S
Swen Schillig 已提交
975
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
976 977 978 979
		goto skip_fsfstatus;

	switch (header->fsf_status) {
        case FSF_GOOD:
S
Swen Schillig 已提交
980 981
		zfcp_san_dbf_event_ct_response(req);
		send_ct->status = 0;
L
Linus Torvalds 已提交
982 983
		break;
        case FSF_SERVICE_CLASS_NOT_SUPPORTED:
S
Swen Schillig 已提交
984
		zfcp_fsf_class_not_supp(req);
L
Linus Torvalds 已提交
985 986 987 988 989
		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 已提交
990
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
991 992 993 994 995 996
			break;
                }
                break;
	case FSF_ACCESS_DENIED:
		break;
        case FSF_PORT_BOXED:
S
Swen Schillig 已提交
997 998
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
999
		break;
S
Swen Schillig 已提交
1000 1001 1002
	case FSF_PORT_HANDLE_NOT_VALID:
		zfcp_erp_adapter_reopen(adapter, 0, 106, req);
	case FSF_GENERIC_COMMAND_REJECTED:
L
Linus Torvalds 已提交
1003 1004 1005 1006
	case FSF_PAYLOAD_SIZE_MISMATCH:
	case FSF_REQUEST_SIZE_TOO_LARGE:
	case FSF_RESPONSE_SIZE_TOO_LARGE:
	case FSF_SBAL_MISMATCH:
S
Swen Schillig 已提交
1007
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1008 1009 1010 1011
		break;
	}

skip_fsfstatus:
S
Swen Schillig 已提交
1012
	if (send_ct->handler)
L
Linus Torvalds 已提交
1013
		send_ct->handler(send_ct->handler_data);
S
Swen Schillig 已提交
1014
}
L
Linus Torvalds 已提交
1015

1016 1017 1018 1019
static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
				       struct scatterlist *sg_req,
				       struct scatterlist *sg_resp,
				       int max_sbals)
S
Swen Schillig 已提交
1020
{
1021 1022
	struct qdio_buffer_element *sbale = zfcp_qdio_sbale_req(req);
	u32 feat = req->adapter->adapter_features;
S
Swen Schillig 已提交
1023 1024
	int bytes;

1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
	if (!(feat & FSF_FEATURE_ELS_CT_CHAINED_SBALS)) {
		if (sg_req->length > PAGE_SIZE || sg_resp->length > PAGE_SIZE ||
		    !sg_is_last(sg_req) || !sg_is_last(sg_resp))
			return -EOPNOTSUPP;

		sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE_READ;
		sbale[2].addr   = sg_virt(sg_req);
		sbale[2].length = sg_req->length;
		sbale[3].addr   = sg_virt(sg_resp);
		sbale[3].length = sg_resp->length;
		sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY;
		return 0;
	}

S
Swen Schillig 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
	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 已提交
1053 1054 1055
}

/**
S
Swen Schillig 已提交
1056 1057 1058 1059
 * 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 已提交
1060
 */
S
Swen Schillig 已提交
1061 1062
int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool,
		     struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1063
{
1064 1065
	struct zfcp_wka_port *wka_port = ct->wka_port;
	struct zfcp_adapter *adapter = wka_port->adapter;
S
Swen Schillig 已提交
1066 1067
	struct zfcp_fsf_req *req;
	int ret = -EIO;
L
Linus Torvalds 已提交
1068

1069
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
1070 1071
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;
L
Linus Torvalds 已提交
1072

S
Swen Schillig 已提交
1073 1074
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_GENERIC,
				  ZFCP_REQ_AUTO_CLEANUP, pool);
1075
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1076 1077
		ret = PTR_ERR(req);
		goto out;
1078 1079
	}

1080 1081
	ret = zfcp_fsf_setup_ct_els_sbals(req, ct->req, ct->resp,
					  FSF_MAX_SBALS_PER_REQ);
C
Christof Schmitt 已提交
1082
	if (ret)
L
Linus Torvalds 已提交
1083 1084
		goto failed_send;

S
Swen Schillig 已提交
1085
	req->handler = zfcp_fsf_send_ct_handler;
1086
	req->qtcb->header.port_handle = wka_port->handle;
S
Swen Schillig 已提交
1087 1088 1089 1090 1091 1092 1093 1094 1095
	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;
1096
		zfcp_fsf_start_erp_timer(req);
S
Swen Schillig 已提交
1097 1098
	} else
		zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
L
Linus Torvalds 已提交
1099

S
Swen Schillig 已提交
1100 1101 1102
	ret = zfcp_fsf_req_send(req);
	if (ret)
		goto failed_send;
L
Linus Torvalds 已提交
1103

S
Swen Schillig 已提交
1104
	goto out;
L
Linus Torvalds 已提交
1105

S
Swen Schillig 已提交
1106 1107 1108 1109 1110
failed_send:
	zfcp_fsf_req_free(req);
	if (erp_action)
		erp_action->fsf_req = NULL;
out:
1111
	spin_unlock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
1112
	return ret;
L
Linus Torvalds 已提交
1113 1114
}

S
Swen Schillig 已提交
1115
static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1116
{
S
Swen Schillig 已提交
1117 1118 1119
	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 已提交
1120

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

S
Swen Schillig 已提交
1123
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
L
Linus Torvalds 已提交
1124 1125 1126 1127
		goto skip_fsfstatus;

	switch (header->fsf_status) {
	case FSF_GOOD:
S
Swen Schillig 已提交
1128 1129
		zfcp_san_dbf_event_els_response(req);
		send_els->status = 0;
L
Linus Torvalds 已提交
1130 1131
		break;
	case FSF_SERVICE_CLASS_NOT_SUPPORTED:
S
Swen Schillig 已提交
1132
		zfcp_fsf_class_not_supp(req);
L
Linus Torvalds 已提交
1133 1134 1135 1136
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		switch (header->fsf_status_qual.word[0]){
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1137 1138
			if (port && (send_els->ls_code != ZFCP_LS_ADISC))
				zfcp_test_link(port);
S
Swen Schillig 已提交
1139
			/*fall through */
L
Linus Torvalds 已提交
1140 1141
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
		case FSF_SQ_RETRY_IF_POSSIBLE:
S
Swen Schillig 已提交
1142
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1143 1144 1145 1146 1147 1148 1149 1150 1151
			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 已提交
1152
		zfcp_fsf_access_denied_port(req, port);
L
Linus Torvalds 已提交
1153
		break;
S
Swen Schillig 已提交
1154 1155 1156
	case FSF_SBAL_MISMATCH:
		/* should never occure, avoided in zfcp_fsf_send_els */
		/* fall through */
L
Linus Torvalds 已提交
1157
	default:
S
Swen Schillig 已提交
1158
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1159 1160 1161
		break;
	}
skip_fsfstatus:
H
Heiko Carstens 已提交
1162
	if (send_els->handler)
L
Linus Torvalds 已提交
1163
		send_els->handler(send_els->handler_data);
S
Swen Schillig 已提交
1164
}
L
Linus Torvalds 已提交
1165

S
Swen Schillig 已提交
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
/**
 * 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;

1181
	spin_lock(&adapter->req_q_lock);
1182
	if (!zfcp_fsf_sbal_available(adapter))
S
Swen Schillig 已提交
1183 1184 1185
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS,
				  ZFCP_REQ_AUTO_CLEANUP, NULL);
1186
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1187 1188 1189 1190
		ret = PTR_ERR(req);
		goto out;
	}

1191
	ret = zfcp_fsf_setup_ct_els_sbals(req, els->req, els->resp, 2);
1192

S
Swen Schillig 已提交
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
	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:
1215
	spin_unlock(&adapter->req_q_lock);
S
Swen Schillig 已提交
1216
	return ret;
L
Linus Torvalds 已提交
1217 1218
}

S
Swen Schillig 已提交
1219
int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1220
{
1221
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1222
	struct zfcp_fsf_req *req;
1223
	struct zfcp_adapter *adapter = erp_action->adapter;
S
Swen Schillig 已提交
1224 1225
	int retval = -EIO;

1226
	spin_lock_bh(&adapter->req_q_lock);
1227
	if (!zfcp_fsf_sbal_available(adapter))
S
Swen Schillig 已提交
1228 1229 1230 1231 1232
		goto out;
	req = zfcp_fsf_req_create(adapter,
				  FSF_QTCB_EXCHANGE_CONFIG_DATA,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
1233
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1234 1235
		retval = PTR_ERR(req);
		goto out;
L
Linus Torvalds 已提交
1236 1237
	}

S
Swen Schillig 已提交
1238
	sbale = zfcp_qdio_sbale_req(req);
1239 1240
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
1241

S
Swen Schillig 已提交
1242
	req->qtcb->bottom.config.feature_selection =
1243 1244
			FSF_FEATURE_CFDC |
			FSF_FEATURE_LUN_SHARING |
1245
			FSF_FEATURE_NOTIFICATION_LOST |
1246
			FSF_FEATURE_UPDATE_ALERT;
S
Swen Schillig 已提交
1247 1248 1249
	req->erp_action = erp_action;
	req->handler = zfcp_fsf_exchange_config_data_handler;
	erp_action->fsf_req = req;
L
Linus Torvalds 已提交
1250

1251
	zfcp_fsf_start_erp_timer(req);
S
Swen Schillig 已提交
1252
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1253
	if (retval) {
S
Swen Schillig 已提交
1254
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1255 1256
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1257
out:
1258
	spin_unlock_bh(&adapter->req_q_lock);
1259 1260
	return retval;
}
L
Linus Torvalds 已提交
1261

S
Swen Schillig 已提交
1262 1263
int zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter,
				       struct fsf_qtcb_bottom_config *data)
1264
{
1265
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1266 1267 1268
	struct zfcp_fsf_req *req = NULL;
	int retval = -EIO;

1269
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
1270 1271 1272 1273 1274
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;

	req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_CONFIG_DATA,
				  0, NULL);
1275
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1276 1277
		retval = PTR_ERR(req);
		goto out;
1278 1279
	}

S
Swen Schillig 已提交
1280
	sbale = zfcp_qdio_sbale_req(req);
1281 1282
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
S
Swen Schillig 已提交
1283
	req->handler = zfcp_fsf_exchange_config_data_handler;
1284

S
Swen Schillig 已提交
1285
	req->qtcb->bottom.config.feature_selection =
1286 1287 1288 1289 1290 1291
			FSF_FEATURE_CFDC |
			FSF_FEATURE_LUN_SHARING |
			FSF_FEATURE_NOTIFICATION_LOST |
			FSF_FEATURE_UPDATE_ALERT;

	if (data)
S
Swen Schillig 已提交
1292
		req->data = data;
1293

S
Swen Schillig 已提交
1294 1295 1296
	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	retval = zfcp_fsf_req_send(req);
out:
1297
	spin_unlock_bh(&adapter->req_q_lock);
C
Christof Schmitt 已提交
1298
	if (!retval)
S
Swen Schillig 已提交
1299 1300
		wait_event(req->completion_wq,
			   req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
1301

S
Swen Schillig 已提交
1302
	zfcp_fsf_req_free(req);
1303

L
Linus Torvalds 已提交
1304 1305 1306 1307 1308
	return retval;
}

/**
 * zfcp_fsf_exchange_port_data - request information about local port
1309
 * @erp_action: ERP action for the adapter for which port data is requested
S
Swen Schillig 已提交
1310
 * Returns: 0 on success, error otherwise
L
Linus Torvalds 已提交
1311
 */
S
Swen Schillig 已提交
1312
int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1313
{
1314
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1315
	struct zfcp_fsf_req *req;
1316
	struct zfcp_adapter *adapter = erp_action->adapter;
S
Swen Schillig 已提交
1317
	int retval = -EIO;
L
Linus Torvalds 已提交
1318

C
Christof Schmitt 已提交
1319
	if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1320
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
1321

1322
	spin_lock_bh(&adapter->req_q_lock);
1323
	if (!zfcp_fsf_sbal_available(adapter))
S
Swen Schillig 已提交
1324 1325 1326 1327
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
1328
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1329 1330
		retval = PTR_ERR(req);
		goto out;
1331 1332
	}

S
Swen Schillig 已提交
1333
	sbale = zfcp_qdio_sbale_req(req);
1334 1335
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
1336

S
Swen Schillig 已提交
1337 1338 1339
	req->handler = zfcp_fsf_exchange_port_data_handler;
	req->erp_action = erp_action;
	erp_action->fsf_req = req;
1340

1341
	zfcp_fsf_start_erp_timer(req);
S
Swen Schillig 已提交
1342
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1343
	if (retval) {
S
Swen Schillig 已提交
1344
		zfcp_fsf_req_free(req);
1345 1346
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1347
out:
1348
	spin_unlock_bh(&adapter->req_q_lock);
1349 1350 1351 1352 1353
	return retval;
}

/**
 * zfcp_fsf_exchange_port_data_sync - request information about local port
S
Swen Schillig 已提交
1354 1355 1356
 * @adapter: pointer to struct zfcp_adapter
 * @data: pointer to struct fsf_qtcb_bottom_port
 * Returns: 0 on success, error otherwise
1357
 */
S
Swen Schillig 已提交
1358 1359
int zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter *adapter,
				     struct fsf_qtcb_bottom_port *data)
1360
{
1361
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1362 1363
	struct zfcp_fsf_req *req = NULL;
	int retval = -EIO;
1364

C
Christof Schmitt 已提交
1365
	if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1366 1367
		return -EOPNOTSUPP;

1368
	spin_lock_bh(&adapter->req_q_lock);
1369
	if (!zfcp_fsf_sbal_available(adapter))
S
Swen Schillig 已提交
1370 1371 1372 1373
		goto out;

	req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA, 0,
				  NULL);
1374
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1375 1376
		retval = PTR_ERR(req);
		goto out;
L
Linus Torvalds 已提交
1377 1378
	}

1379
	if (data)
S
Swen Schillig 已提交
1380
		req->data = data;
1381

S
Swen Schillig 已提交
1382
	sbale = zfcp_qdio_sbale_req(req);
1383 1384 1385
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
1386 1387 1388 1389
	req->handler = zfcp_fsf_exchange_port_data_handler;
	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	retval = zfcp_fsf_req_send(req);
out:
1390
	spin_unlock_bh(&adapter->req_q_lock);
C
Christof Schmitt 已提交
1391
	if (!retval)
S
Swen Schillig 已提交
1392 1393 1394
		wait_event(req->completion_wq,
			   req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
	zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1395 1396 1397 1398

	return retval;
}

S
Swen Schillig 已提交
1399
static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1400
{
S
Swen Schillig 已提交
1401 1402
	struct zfcp_port *port = req->data;
	struct fsf_qtcb_header *header = &req->qtcb->header;
L
Linus Torvalds 已提交
1403 1404
	struct fsf_plogi *plogi;

S
Swen Schillig 已提交
1405
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1406
		return;
L
Linus Torvalds 已提交
1407 1408 1409 1410 1411

	switch (header->fsf_status) {
	case FSF_PORT_ALREADY_OPEN:
		break;
	case FSF_ACCESS_DENIED:
S
Swen Schillig 已提交
1412
		zfcp_fsf_access_denied_port(req, port);
L
Linus Torvalds 已提交
1413 1414
		break;
	case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
S
Swen Schillig 已提交
1415
		dev_warn(&req->adapter->ccw_device->dev,
1416
			 "Not enough FCP adapter resources to open "
1417 1418
			 "remote port 0x%016Lx\n",
			 (unsigned long long)port->wwpn);
S
Swen Schillig 已提交
1419 1420
		zfcp_erp_port_failed(port, 31, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1421 1422 1423 1424 1425 1426
		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:
		case FSF_SQ_NO_RETRY_POSSIBLE:
S
Swen Schillig 已提交
1427
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1428 1429 1430 1431 1432 1433 1434
			break;
		}
		break;
	case FSF_GOOD:
		port->handle = header->port_handle;
		atomic_set_mask(ZFCP_STATUS_COMMON_OPEN |
				ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1435 1436 1437
		atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
		                  ZFCP_STATUS_COMMON_ACCESS_BOXED,
		                  &port->status);
L
Linus Torvalds 已提交
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
		/* 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 已提交
1453
		plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els;
1454 1455
		if (req->qtcb->bottom.support.els1_length >=
		    FSF_PLOGI_MIN_LEN) {
S
Swen Schillig 已提交
1456
			if (plogi->serv_param.wwpn != port->wwpn)
1457
				port->d_id = 0;
S
Swen Schillig 已提交
1458 1459 1460
			else {
				port->wwnn = plogi->serv_param.wwnn;
				zfcp_fc_plogi_evaluate(port, plogi);
L
Linus Torvalds 已提交
1461 1462 1463 1464
			}
		}
		break;
	case FSF_UNKNOWN_OP_SUBTYPE:
S
Swen Schillig 已提交
1465
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1466 1467 1468 1469
		break;
	}
}

S
Swen Schillig 已提交
1470 1471 1472 1473
/**
 * 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 已提交
1474
 */
S
Swen Schillig 已提交
1475
int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1476
{
1477
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1478 1479 1480 1481
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

1482
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
1483 1484 1485 1486 1487 1488 1489
	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);
1490
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1491
		retval = PTR_ERR(req);
L
Linus Torvalds 已提交
1492
		goto out;
S
Swen Schillig 已提交
1493
	}
L
Linus Torvalds 已提交
1494

S
Swen Schillig 已提交
1495
	sbale = zfcp_qdio_sbale_req(req);
L
Linus Torvalds 已提交
1496 1497 1498
        sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
        sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
1499 1500 1501 1502 1503 1504
	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;

1505
	zfcp_fsf_start_erp_timer(req);
S
Swen Schillig 已提交
1506
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1507
	if (retval) {
S
Swen Schillig 已提交
1508
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1509 1510
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1511
out:
1512
	spin_unlock_bh(&adapter->req_q_lock);
L
Linus Torvalds 已提交
1513 1514 1515
	return retval;
}

S
Swen Schillig 已提交
1516
static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1517
{
S
Swen Schillig 已提交
1518
	struct zfcp_port *port = req->data;
L
Linus Torvalds 已提交
1519

S
Swen Schillig 已提交
1520
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1521
		return;
L
Linus Torvalds 已提交
1522

S
Swen Schillig 已提交
1523
	switch (req->qtcb->header.fsf_status) {
L
Linus Torvalds 已提交
1524
	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1525 1526
		zfcp_erp_adapter_reopen(port->adapter, 0, 107, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1527 1528 1529 1530
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		break;
	case FSF_GOOD:
S
Swen Schillig 已提交
1531
		zfcp_erp_modify_port_status(port, 33, req,
L
Linus Torvalds 已提交
1532 1533 1534 1535 1536 1537
					    ZFCP_STATUS_COMMON_OPEN,
					    ZFCP_CLEAR);
		break;
	}
}

S
Swen Schillig 已提交
1538 1539 1540 1541
/**
 * 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 已提交
1542
 */
S
Swen Schillig 已提交
1543
int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1544
{
1545
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1546 1547 1548 1549
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

1550
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
1551 1552 1553 1554 1555 1556
	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);
1557
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1558
		retval = PTR_ERR(req);
L
Linus Torvalds 已提交
1559
		goto out;
S
Swen Schillig 已提交
1560
	}
L
Linus Torvalds 已提交
1561

S
Swen Schillig 已提交
1562
	sbale = zfcp_qdio_sbale_req(req);
L
Linus Torvalds 已提交
1563 1564 1565
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
1566 1567 1568 1569 1570 1571
	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;

1572
	zfcp_fsf_start_erp_timer(req);
S
Swen Schillig 已提交
1573
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1574
	if (retval) {
S
Swen Schillig 已提交
1575
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1576 1577
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1578
out:
1579
	spin_unlock_bh(&adapter->req_q_lock);
L
Linus Torvalds 已提交
1580 1581 1582
	return retval;
}

1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602
static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
{
	struct zfcp_wka_port *wka_port = req->data;
	struct fsf_qtcb_header *header = &req->qtcb->header;

	if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
		wka_port->status = ZFCP_WKA_PORT_OFFLINE;
		goto out;
	}

	switch (header->fsf_status) {
	case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
		dev_warn(&req->adapter->ccw_device->dev,
			 "Opening WKA port 0x%x failed\n", wka_port->d_id);
	case FSF_ADAPTER_STATUS_AVAILABLE:
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
	case FSF_ACCESS_DENIED:
		wka_port->status = ZFCP_WKA_PORT_OFFLINE;
		break;
	case FSF_PORT_ALREADY_OPEN:
1603
		break;
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
	case FSF_GOOD:
		wka_port->handle = header->port_handle;
		wka_port->status = ZFCP_WKA_PORT_ONLINE;
	}
out:
	wake_up(&wka_port->completion_wq);
}

/**
 * zfcp_fsf_open_wka_port - create and send open wka-port request
 * @wka_port: pointer to struct zfcp_wka_port
 * Returns: 0 on success, error otherwise
 */
int zfcp_fsf_open_wka_port(struct zfcp_wka_port *wka_port)
{
	struct qdio_buffer_element *sbale;
	struct zfcp_adapter *adapter = wka_port->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

1624
	spin_lock_bh(&adapter->req_q_lock);
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649
	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);
		goto out;
	}

	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

	req->handler = zfcp_fsf_open_wka_port_handler;
	req->qtcb->bottom.support.d_id = wka_port->d_id;
	req->data = wka_port;

	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	retval = zfcp_fsf_req_send(req);
	if (retval)
		zfcp_fsf_req_free(req);
out:
1650
	spin_unlock_bh(&adapter->req_q_lock);
1651 1652 1653 1654 1655 1656 1657 1658 1659
	return retval;
}

static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
{
	struct zfcp_wka_port *wka_port = req->data;

	if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1660
		zfcp_erp_adapter_reopen(wka_port->adapter, 0, 84, req);
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
	}

	wka_port->status = ZFCP_WKA_PORT_OFFLINE;
	wake_up(&wka_port->completion_wq);
}

/**
 * zfcp_fsf_close_wka_port - create and send close wka port request
 * @erp_action: pointer to struct zfcp_erp_action
 * Returns: 0 on success, error otherwise
 */
int zfcp_fsf_close_wka_port(struct zfcp_wka_port *wka_port)
{
	struct qdio_buffer_element *sbale;
	struct zfcp_adapter *adapter = wka_port->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

1679
	spin_lock_bh(&adapter->req_q_lock);
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
	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);
		goto out;
	}

	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

	req->handler = zfcp_fsf_close_wka_port_handler;
	req->data = wka_port;
	req->qtcb->header.port_handle = wka_port->handle;

	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	retval = zfcp_fsf_req_send(req);
	if (retval)
		zfcp_fsf_req_free(req);
out:
1704
	spin_unlock_bh(&adapter->req_q_lock);
1705 1706 1707
	return retval;
}

S
Swen Schillig 已提交
1708
static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1709
{
S
Swen Schillig 已提交
1710 1711
	struct zfcp_port *port = req->data;
	struct fsf_qtcb_header *header = &req->qtcb->header;
L
Linus Torvalds 已提交
1712 1713
	struct zfcp_unit *unit;

S
Swen Schillig 已提交
1714
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1715
		return;
L
Linus Torvalds 已提交
1716 1717 1718

	switch (header->fsf_status) {
	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1719 1720
		zfcp_erp_adapter_reopen(port->adapter, 0, 108, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1721 1722
		break;
	case FSF_ACCESS_DENIED:
S
Swen Schillig 已提交
1723
		zfcp_fsf_access_denied_port(req, port);
L
Linus Torvalds 已提交
1724 1725
		break;
	case FSF_PORT_BOXED:
S
Swen Schillig 已提交
1726 1727 1728
		zfcp_erp_port_boxed(port, 50, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
1729 1730 1731 1732 1733 1734
		/* 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 已提交
1735 1736 1737 1738
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		switch (header->fsf_status_qual.word[0]) {
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
S
Swen Schillig 已提交
1739
			/* fall through */
L
Linus Torvalds 已提交
1740
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
1741
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1742 1743 1744 1745 1746 1747 1748 1749 1750
			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 已提交
1751 1752
			atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
					  &unit->status);
L
Linus Torvalds 已提交
1753 1754 1755 1756
		break;
	}
}

S
Swen Schillig 已提交
1757 1758 1759 1760
/**
 * zfcp_fsf_close_physical_port - close physical port
 * @erp_action: pointer to struct zfcp_erp_action
 * Returns: 0 on success
L
Linus Torvalds 已提交
1761
 */
S
Swen Schillig 已提交
1762
int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
1763
{
1764
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
1765 1766 1767 1768
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;

1769
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
1770
	if (zfcp_fsf_req_sbal_get(adapter))
L
Linus Torvalds 已提交
1771 1772
		goto out;

S
Swen Schillig 已提交
1773 1774 1775
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PHYSICAL_PORT,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
1776
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1777 1778 1779
		retval = PTR_ERR(req);
		goto out;
	}
L
Linus Torvalds 已提交
1780

S
Swen Schillig 已提交
1781 1782 1783
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
L
Linus Torvalds 已提交
1784

S
Swen Schillig 已提交
1785 1786 1787 1788 1789 1790
	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;

1791
	zfcp_fsf_start_erp_timer(req);
S
Swen Schillig 已提交
1792
	retval = zfcp_fsf_req_send(req);
L
Linus Torvalds 已提交
1793
	if (retval) {
S
Swen Schillig 已提交
1794
		zfcp_fsf_req_free(req);
L
Linus Torvalds 已提交
1795 1796
		erp_action->fsf_req = NULL;
	}
S
Swen Schillig 已提交
1797
out:
1798
	spin_unlock_bh(&adapter->req_q_lock);
L
Linus Torvalds 已提交
1799 1800 1801
	return retval;
}

S
Swen Schillig 已提交
1802
static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1803
{
S
Swen Schillig 已提交
1804 1805 1806 1807 1808 1809
	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;
1810
	int exclusive, readwrite;
L
Linus Torvalds 已提交
1811

S
Swen Schillig 已提交
1812
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1813
		return;
L
Linus Torvalds 已提交
1814 1815

	atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1816
			  ZFCP_STATUS_COMMON_ACCESS_BOXED |
L
Linus Torvalds 已提交
1817 1818 1819 1820 1821 1822 1823
			  ZFCP_STATUS_UNIT_SHARED |
			  ZFCP_STATUS_UNIT_READONLY,
			  &unit->status);

	switch (header->fsf_status) {

	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1824 1825
		zfcp_erp_adapter_reopen(unit->port->adapter, 0, 109, req);
		/* fall through */
L
Linus Torvalds 已提交
1826 1827 1828
	case FSF_LUN_ALREADY_OPEN:
		break;
	case FSF_ACCESS_DENIED:
S
Swen Schillig 已提交
1829
		zfcp_fsf_access_denied_unit(req, unit);
L
Linus Torvalds 已提交
1830
		atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
C
Christof Schmitt 已提交
1831
		atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
L
Linus Torvalds 已提交
1832 1833
		break;
	case FSF_PORT_BOXED:
S
Swen Schillig 已提交
1834 1835 1836
		zfcp_erp_port_boxed(unit->port, 51, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
1837 1838
		break;
	case FSF_LUN_SHARING_VIOLATION:
S
Swen Schillig 已提交
1839
		if (header->fsf_status_qual.word[0])
C
Christof Schmitt 已提交
1840
			dev_warn(&adapter->ccw_device->dev,
1841 1842
				 "LUN 0x%Lx on port 0x%Lx is already in "
				 "use by CSS%d, MIF Image ID %x\n",
1843 1844
				 (unsigned long long)unit->fcp_lun,
				 (unsigned long long)unit->port->wwpn,
1845 1846
				 queue_designator->cssid,
				 queue_designator->hla);
S
Swen Schillig 已提交
1847
		else
C
Christof Schmitt 已提交
1848 1849
			zfcp_act_eval_err(adapter,
					  header->fsf_status_qual.word[2]);
S
Swen Schillig 已提交
1850
		zfcp_erp_unit_access_denied(unit, 60, req);
L
Linus Torvalds 已提交
1851 1852
		atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
		atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
S
Swen Schillig 已提交
1853
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1854 1855
		break;
	case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
S
Swen Schillig 已提交
1856
		dev_warn(&adapter->ccw_device->dev,
1857 1858
			 "No handle is available for LUN "
			 "0x%016Lx on port 0x%016Lx\n",
1859 1860
			 (unsigned long long)unit->fcp_lun,
			 (unsigned long long)unit->port->wwpn);
S
Swen Schillig 已提交
1861 1862 1863 1864
		zfcp_erp_unit_failed(unit, 34, req);
		/* fall through */
	case FSF_INVALID_COMMAND_OPTION:
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1865 1866 1867 1868
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
		switch (header->fsf_status_qual.word[0]) {
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1869
			zfcp_test_link(unit->port);
S
Swen Schillig 已提交
1870
			/* fall through */
L
Linus Torvalds 已提交
1871
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
1872
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1873 1874 1875 1876 1877 1878 1879
			break;
		}
		break;

	case FSF_GOOD:
		unit->handle = header->lun_handle;
		atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
1880 1881 1882 1883 1884 1885 1886 1887 1888

		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 已提交
1889 1890 1891 1892 1893 1894 1895
			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 已提交
1896
				dev_info(&adapter->ccw_device->dev,
1897 1898
					 "SCSI device at LUN 0x%016Lx on port "
					 "0x%016Lx opened read-only\n",
1899 1900
					 (unsigned long long)unit->fcp_lun,
					 (unsigned long long)unit->port->wwpn);
L
Linus Torvalds 已提交
1901 1902 1903
        		}

        		if (exclusive && !readwrite) {
S
Swen Schillig 已提交
1904
				dev_err(&adapter->ccw_device->dev,
1905 1906 1907
					"Exclusive read-only access not "
					"supported (unit 0x%016Lx, "
					"port 0x%016Lx)\n",
1908 1909
					(unsigned long long)unit->fcp_lun,
					(unsigned long long)unit->port->wwpn);
S
Swen Schillig 已提交
1910 1911 1912
				zfcp_erp_unit_failed(unit, 35, req);
				req->status |= ZFCP_STATUS_FSFREQ_ERROR;
				zfcp_erp_unit_shutdown(unit, 0, 80, req);
L
Linus Torvalds 已提交
1913
        		} else if (!exclusive && readwrite) {
S
Swen Schillig 已提交
1914
				dev_err(&adapter->ccw_device->dev,
1915 1916
					"Shared read-write access not "
					"supported (unit 0x%016Lx, port "
1917
					"0x%016Lx)\n",
1918 1919
					(unsigned long long)unit->fcp_lun,
					(unsigned long long)unit->port->wwpn);
S
Swen Schillig 已提交
1920 1921 1922
				zfcp_erp_unit_failed(unit, 36, req);
				req->status |= ZFCP_STATUS_FSFREQ_ERROR;
				zfcp_erp_unit_shutdown(unit, 0, 81, req);
L
Linus Torvalds 已提交
1923 1924 1925 1926 1927 1928
        		}
		}
		break;
	}
}

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

1941
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
1942
	if (zfcp_fsf_req_sbal_get(adapter))
L
Linus Torvalds 已提交
1943 1944
		goto out;

S
Swen Schillig 已提交
1945 1946 1947
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_OPEN_LUN,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
1948
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
1949 1950 1951 1952 1953
		retval = PTR_ERR(req);
		goto out;
	}

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

S
Swen Schillig 已提交
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966
	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;

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

S
Swen Schillig 已提交
1978
static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
1979
{
S
Swen Schillig 已提交
1980
	struct zfcp_unit *unit = req->data;
L
Linus Torvalds 已提交
1981

S
Swen Schillig 已提交
1982
	if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1983
		return;
L
Linus Torvalds 已提交
1984

S
Swen Schillig 已提交
1985
	switch (req->qtcb->header.fsf_status) {
L
Linus Torvalds 已提交
1986
	case FSF_PORT_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1987 1988
		zfcp_erp_adapter_reopen(unit->port->adapter, 0, 110, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1989 1990
		break;
	case FSF_LUN_HANDLE_NOT_VALID:
S
Swen Schillig 已提交
1991 1992
		zfcp_erp_port_reopen(unit->port, 0, 111, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
1993 1994
		break;
	case FSF_PORT_BOXED:
S
Swen Schillig 已提交
1995 1996 1997
		zfcp_erp_port_boxed(unit->port, 52, req);
		req->status |= ZFCP_STATUS_FSFREQ_ERROR |
			       ZFCP_STATUS_FSFREQ_RETRY;
L
Linus Torvalds 已提交
1998 1999
		break;
	case FSF_ADAPTER_STATUS_AVAILABLE:
S
Swen Schillig 已提交
2000
		switch (req->qtcb->header.fsf_status_qual.word[0]) {
L
Linus Torvalds 已提交
2001
		case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
2002
			zfcp_test_link(unit->port);
S
Swen Schillig 已提交
2003
			/* fall through */
L
Linus Torvalds 已提交
2004
		case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
S
Swen Schillig 已提交
2005
			req->status |= ZFCP_STATUS_FSFREQ_ERROR;
L
Linus Torvalds 已提交
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015
			break;
		}
		break;
	case FSF_GOOD:
		atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
		break;
	}
}

/**
S
Swen Schillig 已提交
2016 2017 2018
 * zfcp_fsf_close_unit - close zfcp unit
 * @erp_action: pointer to struct zfcp_unit
 * Returns: 0 on success, error otherwise
L
Linus Torvalds 已提交
2019
 */
S
Swen Schillig 已提交
2020
int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
L
Linus Torvalds 已提交
2021
{
2022
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
2023 2024 2025
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_fsf_req *req;
	int retval = -EIO;
L
Linus Torvalds 已提交
2026

2027
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
2028
	if (zfcp_fsf_req_sbal_get(adapter))
L
Linus Torvalds 已提交
2029
		goto out;
S
Swen Schillig 已提交
2030 2031 2032
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_LUN,
				  ZFCP_REQ_AUTO_CLEANUP,
				  adapter->pool.fsf_req_erp);
2033
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
2034 2035 2036
		retval = PTR_ERR(req);
		goto out;
	}
L
Linus Torvalds 已提交
2037

S
Swen Schillig 已提交
2038 2039
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
L
Linus Torvalds 已提交
2040 2041
	sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;

S
Swen Schillig 已提交
2042 2043 2044 2045 2046 2047
	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;
2048

2049
	zfcp_fsf_start_erp_timer(req);
S
Swen Schillig 已提交
2050 2051 2052 2053 2054 2055
	retval = zfcp_fsf_req_send(req);
	if (retval) {
		zfcp_fsf_req_free(req);
		erp_action->fsf_req = NULL;
	}
out:
2056
	spin_unlock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
2057
	return retval;
L
Linus Torvalds 已提交
2058 2059
}

2060 2061 2062
static void zfcp_fsf_update_lat(struct fsf_latency_record *lat_rec, u32 lat)
{
	lat_rec->sum += lat;
S
Swen Schillig 已提交
2063 2064
	lat_rec->min = min(lat_rec->min, lat);
	lat_rec->max = max(lat_rec->max, lat);
2065 2066
}

S
Swen Schillig 已提交
2067
static void zfcp_fsf_req_latency(struct zfcp_fsf_req *req)
2068 2069 2070
{
	struct fsf_qual_latency_info *lat_inf;
	struct latency_cont *lat;
S
Swen Schillig 已提交
2071
	struct zfcp_unit *unit = req->unit;
2072 2073
	unsigned long flags;

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

S
Swen Schillig 已提交
2076
	switch (req->qtcb->bottom.io.data_direction) {
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093
	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 已提交
2094
	spin_unlock_irqrestore(&unit->latencies.lock, flags);
L
Linus Torvalds 已提交
2095 2096
}

S
Stefan Raspl 已提交
2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
#ifdef CONFIG_BLK_DEV_IO_TRACE
static void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
{
	struct fsf_qual_latency_info *lat_inf;
	struct scsi_cmnd *scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
	struct request *req = scsi_cmnd->request;
	struct zfcp_blk_drv_data trace;
	int ticks = fsf_req->adapter->timer_ticks;

	trace.flags = 0;
	trace.magic = ZFCP_BLK_DRV_DATA_MAGIC;
	if (fsf_req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) {
		trace.flags |= ZFCP_BLK_LAT_VALID;
		lat_inf = &fsf_req->qtcb->prefix.prot_status_qual.latency_info;
		trace.channel_lat = lat_inf->channel_lat * ticks;
		trace.fabric_lat = lat_inf->fabric_lat * ticks;
	}
	if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
		trace.flags |= ZFCP_BLK_REQ_ERROR;
	trace.inb_usage = fsf_req->qdio_inb_usage;
	trace.outb_usage = fsf_req->qdio_outb_usage;

	blk_add_driver_data(req->q, req, &trace, sizeof(trace));
}
#else
static inline void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
{
}
#endif

S
Swen Schillig 已提交
2127
static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
2128
{
2129
	struct scsi_cmnd *scpnt;
L
Linus Torvalds 已提交
2130
	struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
S
Swen Schillig 已提交
2131
	    &(req->qtcb->bottom.io.fcp_rsp);
L
Linus Torvalds 已提交
2132
	u32 sns_len;
2133
	char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
L
Linus Torvalds 已提交
2134 2135
	unsigned long flags;

S
Swen Schillig 已提交
2136 2137
	read_lock_irqsave(&req->adapter->abort_lock, flags);

2138 2139 2140 2141 2142 2143
	scpnt = req->data;
	if (unlikely(!scpnt)) {
		read_unlock_irqrestore(&req->adapter->abort_lock, flags);
		return;
	}

S
Swen Schillig 已提交
2144
	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ABORTED)) {
2145
		set_host_byte(scpnt, DID_SOFT_ERROR);
L
Linus Torvalds 已提交
2146 2147 2148
		goto skip_fsfstatus;
	}

S
Swen Schillig 已提交
2149
	if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
2150
		set_host_byte(scpnt, DID_ERROR);
L
Linus Torvalds 已提交
2151 2152 2153
		goto skip_fsfstatus;
	}

2154
	set_msg_byte(scpnt, COMMAND_COMPLETE);
L
Linus Torvalds 已提交
2155 2156 2157

	scpnt->result |= fcp_rsp_iu->scsi_status;

S
Swen Schillig 已提交
2158 2159
	if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)
		zfcp_fsf_req_latency(req);
2160

S
Stefan Raspl 已提交
2161 2162
	zfcp_fsf_trace_latency(req);

L
Linus Torvalds 已提交
2163
	if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) {
S
Swen Schillig 已提交
2164
		if (fcp_rsp_info[3] == RSP_CODE_GOOD)
2165
			set_host_byte(scpnt, DID_OK);
S
Swen Schillig 已提交
2166
		else {
2167
			set_host_byte(scpnt, DID_ERROR);
已提交
2168
			goto skip_fsfstatus;
L
Linus Torvalds 已提交
2169 2170 2171 2172
		}
	}

	if (unlikely(fcp_rsp_iu->validity.bits.fcp_sns_len_valid)) {
S
Swen Schillig 已提交
2173 2174
		sns_len = FSF_FCP_RSP_SIZE - sizeof(struct fcp_rsp_iu) +
			  fcp_rsp_iu->fcp_rsp_len;
L
Linus Torvalds 已提交
2175 2176 2177
		sns_len = min(sns_len, (u32) SCSI_SENSE_BUFFERSIZE);
		sns_len = min(sns_len, fcp_rsp_iu->fcp_sns_len);

2178
		memcpy(scpnt->sense_buffer,
L
Linus Torvalds 已提交
2179 2180 2181 2182
		       zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu), sns_len);
	}

	if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_under)) {
2183 2184 2185
		scsi_set_resid(scpnt, fcp_rsp_iu->fcp_resid);
		if (scsi_bufflen(scpnt) - scsi_get_resid(scpnt) <
		    scpnt->underflow)
2186
			set_host_byte(scpnt, DID_ERROR);
L
Linus Torvalds 已提交
2187
	}
S
Swen Schillig 已提交
2188
skip_fsfstatus:
2189
	if (scpnt->result != 0)
S
Swen Schillig 已提交
2190
		zfcp_scsi_dbf_event_result("erro", 3, req->adapter, scpnt, req);
2191
	else if (scpnt->retries > 0)
S
Swen Schillig 已提交
2192
		zfcp_scsi_dbf_event_result("retr", 4, req->adapter, scpnt, req);
2193
	else
S
Swen Schillig 已提交
2194
		zfcp_scsi_dbf_event_result("norm", 6, req->adapter, scpnt, req);
L
Linus Torvalds 已提交
2195 2196 2197 2198 2199 2200 2201 2202 2203

	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 已提交
2204
	read_unlock_irqrestore(&req->adapter->abort_lock, flags);
L
Linus Torvalds 已提交
2205 2206
}

S
Swen Schillig 已提交
2207
static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
2208 2209
{
	struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
S
Swen Schillig 已提交
2210
	    &(req->qtcb->bottom.io.fcp_rsp);
2211
	char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
L
Linus Torvalds 已提交
2212

S
Swen Schillig 已提交
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229
	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 已提交
2230 2231
		goto skip_fsfstatus;

S
Swen Schillig 已提交
2232 2233 2234 2235 2236 2237 2238 2239 2240 2241
	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 已提交
2242
		break;
S
Swen Schillig 已提交
2243 2244
	case FSF_SERVICE_CLASS_NOT_SUPPORTED:
		zfcp_fsf_class_not_supp(req);
L
Linus Torvalds 已提交
2245
		break;
S
Swen Schillig 已提交
2246 2247 2248 2249 2250
	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,
2251 2252
			"Incorrect direction %d, unit 0x%016Lx on port "
			"0x%016Lx closed\n",
S
Swen Schillig 已提交
2253
			req->qtcb->bottom.io.data_direction,
2254 2255
			(unsigned long long)unit->fcp_lun,
			(unsigned long long)unit->port->wwpn);
S
Swen Schillig 已提交
2256 2257 2258 2259 2260
		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,
2261 2262
			"Incorrect CDB length %d, unit 0x%016Lx on "
			"port 0x%016Lx closed\n",
S
Swen Schillig 已提交
2263
			req->qtcb->bottom.io.fcp_cmnd_length,
2264 2265
			(unsigned long long)unit->fcp_lun,
			(unsigned long long)unit->port->wwpn);
S
Swen Schillig 已提交
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283
		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 已提交
2284 2285
		break;
	}
S
Swen Schillig 已提交
2286 2287 2288 2289 2290 2291 2292 2293
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 已提交
2294 2295
}

2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
static void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, u32 fcp_dl)
{
	u32 *fcp_dl_ptr;

	/*
	 * fcp_dl_addr = start address of fcp_cmnd structure +
	 * size of fixed part + size of dynamically sized add_dcp_cdb field
	 * SEE FCP-2 documentation
	 */
	fcp_dl_ptr = (u32 *) ((unsigned char *) &fcp_cmd[1] +
			(fcp_cmd->add_fcp_cdb_length << 2));
	*fcp_dl_ptr = fcp_dl;
}

S
Swen Schillig 已提交
2310 2311 2312 2313 2314 2315 2316
/**
 * 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 已提交
2317
 */
S
Swen Schillig 已提交
2318 2319 2320 2321
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 已提交
2322
{
S
Swen Schillig 已提交
2323 2324 2325 2326
	struct zfcp_fsf_req *req;
	struct fcp_cmnd_iu *fcp_cmnd_iu;
	unsigned int sbtype;
	int real_bytes, retval = -EIO;
L
Linus Torvalds 已提交
2327

S
Swen Schillig 已提交
2328 2329 2330
	if (unlikely(!(atomic_read(&unit->status) &
		       ZFCP_STATUS_COMMON_UNBLOCKED)))
		return -EBUSY;
L
Linus Torvalds 已提交
2331

2332
	spin_lock(&adapter->req_q_lock);
2333
	if (!zfcp_fsf_sbal_available(adapter))
S
Swen Schillig 已提交
2334 2335 2336
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
				  adapter->pool.fsf_req_scsi);
2337
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363
		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 已提交
2364
		break;
S
Swen Schillig 已提交
2365 2366 2367 2368 2369 2370 2371 2372 2373
	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 已提交
2374
		break;
S
Swen Schillig 已提交
2375
	case DMA_BIDIRECTIONAL:
L
Linus Torvalds 已提交
2376
	default:
S
Swen Schillig 已提交
2377 2378
		retval = -EIO;
		goto failed_scsi_cmnd;
L
Linus Torvalds 已提交
2379 2380
	}

S
Swen Schillig 已提交
2381 2382 2383 2384 2385 2386
	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 已提交
2387

S
Swen Schillig 已提交
2388 2389 2390
	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 已提交
2391

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

S
Swen Schillig 已提交
2394
	req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
2395
		fcp_cmnd_iu->add_fcp_cdb_length + sizeof(u32);
L
Linus Torvalds 已提交
2396

S
Swen Schillig 已提交
2397 2398 2399 2400 2401 2402 2403 2404
	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,
2405 2406
				"Oversize data package, unit 0x%016Lx "
				"on port 0x%016Lx closed\n",
2407 2408
				(unsigned long long)unit->fcp_lun,
				(unsigned long long)unit->port->wwpn);
S
Swen Schillig 已提交
2409 2410 2411 2412
			zfcp_erp_unit_shutdown(unit, 0, 131, req);
			retval = -EINVAL;
		}
		goto failed_scsi_cmnd;
L
Linus Torvalds 已提交
2413 2414
	}

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

S
Swen Schillig 已提交
2417 2418
	if (use_timer)
		zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
L
Linus Torvalds 已提交
2419

S
Swen Schillig 已提交
2420 2421 2422
	retval = zfcp_fsf_req_send(req);
	if (unlikely(retval))
		goto failed_scsi_cmnd;
L
Linus Torvalds 已提交
2423

S
Swen Schillig 已提交
2424
	goto out;
L
Linus Torvalds 已提交
2425

S
Swen Schillig 已提交
2426 2427 2428 2429 2430
failed_scsi_cmnd:
	zfcp_unit_put(unit);
	zfcp_fsf_req_free(req);
	scsi_cmnd->host_scribble = NULL;
out:
2431
	spin_unlock(&adapter->req_q_lock);
S
Swen Schillig 已提交
2432
	return retval;
L
Linus Torvalds 已提交
2433 2434 2435
}

/**
S
Swen Schillig 已提交
2436 2437 2438 2439 2440 2441
 * 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 已提交
2442
 */
S
Swen Schillig 已提交
2443 2444 2445
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 已提交
2446
{
2447
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
2448 2449
	struct zfcp_fsf_req *req = NULL;
	struct fcp_cmnd_iu *fcp_cmnd_iu;
L
Linus Torvalds 已提交
2450

S
Swen Schillig 已提交
2451 2452 2453
	if (unlikely(!(atomic_read(&unit->status) &
		       ZFCP_STATUS_COMMON_UNBLOCKED)))
		return NULL;
L
Linus Torvalds 已提交
2454

2455
	spin_lock(&adapter->req_q_lock);
2456
	if (!zfcp_fsf_sbal_available(adapter))
S
Swen Schillig 已提交
2457 2458 2459
		goto out;
	req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
				  adapter->pool.fsf_req_scsi);
2460 2461
	if (IS_ERR(req)) {
		req = NULL;
S
Swen Schillig 已提交
2462
		goto out;
2463
	}
L
Linus Torvalds 已提交
2464

S
Swen Schillig 已提交
2465 2466 2467 2468 2469 2470 2471 2472
	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) +
2473
						sizeof(u32);
S
Swen Schillig 已提交
2474 2475 2476 2477

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

S
Swen Schillig 已提交
2479 2480 2481
	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 已提交
2482

S
Swen Schillig 已提交
2483 2484 2485
	zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
	if (!zfcp_fsf_req_send(req))
		goto out;
L
Linus Torvalds 已提交
2486

S
Swen Schillig 已提交
2487 2488 2489
	zfcp_fsf_req_free(req);
	req = NULL;
out:
2490
	spin_unlock(&adapter->req_q_lock);
S
Swen Schillig 已提交
2491 2492
	return req;
}
L
Linus Torvalds 已提交
2493

S
Swen Schillig 已提交
2494 2495 2496 2497
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 已提交
2498 2499
}

S
Swen Schillig 已提交
2500 2501 2502 2503 2504
/**
 * 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 已提交
2505
 */
S
Swen Schillig 已提交
2506 2507
struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
					   struct zfcp_fsf_cfdc *fsf_cfdc)
L
Linus Torvalds 已提交
2508
{
2509
	struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526
	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 已提交
2527

2528
	spin_lock_bh(&adapter->req_q_lock);
S
Swen Schillig 已提交
2529 2530
	if (zfcp_fsf_req_sbal_get(adapter))
		goto out;
L
Linus Torvalds 已提交
2531

S
Swen Schillig 已提交
2532
	req = zfcp_fsf_req_create(adapter, fsf_cfdc->command, 0, NULL);
2533
	if (IS_ERR(req)) {
S
Swen Schillig 已提交
2534 2535 2536
		retval = -EPERM;
		goto out;
	}
L
Linus Torvalds 已提交
2537

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

S
Swen Schillig 已提交
2540 2541
	sbale = zfcp_qdio_sbale_req(req);
	sbale[0].flags |= direction;
2542

S
Swen Schillig 已提交
2543 2544 2545
	bottom = &req->qtcb->bottom.support;
	bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
	bottom->option = fsf_cfdc->option;
2546

S
Swen Schillig 已提交
2547 2548 2549 2550 2551 2552 2553
	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 已提交
2554

S
Swen Schillig 已提交
2555 2556 2557
	zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
	retval = zfcp_fsf_req_send(req);
out:
2558
	spin_unlock_bh(&adapter->req_q_lock);
2559

S
Swen Schillig 已提交
2560 2561 2562 2563
	if (!retval) {
		wait_event(req->completion_wq,
			   req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
		return req;
L
Linus Torvalds 已提交
2564
	}
S
Swen Schillig 已提交
2565
	return ERR_PTR(retval);
L
Linus Torvalds 已提交
2566
}