projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] zfcp: Use correct flags for zfcp_erp_notify
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / s390 / scsi / zfcp_fsf.c
CommitLineData
1da177e4 1/*
553448f6 2 * zfcp device driver
1da177e4 3 *
553448f6 4 * Implementation of FSF commands.
1da177e4 5 *
a2fa0aed 6 * Copyright IBM Corporation 2002, 2009
1da177e4
LT		 7 */
8
ecf39d42
CS		 9#define KMSG_COMPONENT "zfcp"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
0997f1c5 12#include <linux/blktrace_api.h>
1da177e4
LT		 13#include "zfcp_ext.h"
14
63caf367
CS		 15#define ZFCP_REQ_AUTO_CLEANUP 0x00000002
16#define ZFCP_REQ_NO_QTCB 0x00000008
17
287ac01a
CS		 18static void zfcp_fsf_request_timeout_handler(unsigned long data)
19{
20 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
5ffd51a5
SS		 21 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
22 "fsrth_1", NULL);
287ac01a
CS		 23}
24
25static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
26 unsigned long timeout)
27{
28 fsf_req->timer.function = zfcp_fsf_request_timeout_handler;
29 fsf_req->timer.data = (unsigned long) fsf_req->adapter;
30 fsf_req->timer.expires = jiffies + timeout;
31 add_timer(&fsf_req->timer);
32}
33
34static void zfcp_fsf_start_erp_timer(struct zfcp_fsf_req *fsf_req)
35{
36 BUG_ON(!fsf_req->erp_action);
37 fsf_req->timer.function = zfcp_erp_timeout_handler;
38 fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
39 fsf_req->timer.expires = jiffies + 30 * HZ;
40 add_timer(&fsf_req->timer);
41}
42
1da177e4
LT		 43/* association between FSF command and FSF QTCB type */
44static u32 fsf_qtcb_type[] = {
45 [FSF_QTCB_FCP_CMND] = FSF_IO_COMMAND,
46 [FSF_QTCB_ABORT_FCP_CMND] = FSF_SUPPORT_COMMAND,
47 [FSF_QTCB_OPEN_PORT_WITH_DID] = FSF_SUPPORT_COMMAND,
48 [FSF_QTCB_OPEN_LUN] = FSF_SUPPORT_COMMAND,
49 [FSF_QTCB_CLOSE_LUN] = FSF_SUPPORT_COMMAND,
50 [FSF_QTCB_CLOSE_PORT] = FSF_SUPPORT_COMMAND,
51 [FSF_QTCB_CLOSE_PHYSICAL_PORT] = FSF_SUPPORT_COMMAND,
52 [FSF_QTCB_SEND_ELS] = FSF_SUPPORT_COMMAND,
53 [FSF_QTCB_SEND_GENERIC] = FSF_SUPPORT_COMMAND,
54 [FSF_QTCB_EXCHANGE_CONFIG_DATA] = FSF_CONFIG_COMMAND,
55 [FSF_QTCB_EXCHANGE_PORT_DATA] = FSF_PORT_COMMAND,
56 [FSF_QTCB_DOWNLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND,
57 [FSF_QTCB_UPLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND
58};
59
553448f6
CS		 60static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
61{
c41f8cbd 62 u16 subtable = table >> 16;
553448f6 63 u16 rule = table & 0xffff;
ff3b24fa 64 const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" };
553448f6 65
ff3b24fa 66 if (subtable && subtable < ARRAY_SIZE(act_type))
553448f6 67 dev_warn(&adapter->ccw_device->dev,
ff3b24fa
CS		 68 "Access denied according to ACT rule type %s, "
69 "rule %d\n", act_type[subtable], rule);
553448f6
CS		 70}
71
72static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req,
73 struct zfcp_port *port)
74{
75 struct fsf_qtcb_header *header = &req->qtcb->header;
76 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa 77 "Access denied to port 0x%016Lx\n",
7ba58c9c 78 (unsigned long long)port->wwpn);
553448f6
CS		 79 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
80 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
5ffd51a5 81 zfcp_erp_port_access_denied(port, "fspad_1", req);
553448f6
CS		 82 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
83}
84
85static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req *req,
86 struct zfcp_unit *unit)
87{
88 struct fsf_qtcb_header *header = &req->qtcb->header;
89 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa 90 "Access denied to unit 0x%016Lx on port 0x%016Lx\n",
7ba58c9c
SS		 91 (unsigned long long)unit->fcp_lun,
92 (unsigned long long)unit->port->wwpn);
553448f6
CS		 93 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
94 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
5ffd51a5 95 zfcp_erp_unit_access_denied(unit, "fsuad_1", req);
553448f6
CS		 96 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
97}
98
99static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
100{
ff3b24fa
CS		 101 dev_err(&req->adapter->ccw_device->dev, "FCP device not "
102 "operational because of an unsupported FC class\n");
5ffd51a5 103 zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1", req);
553448f6
CS		 104 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
105}
106
c41f8cbd
SS		 107/**
108 * zfcp_fsf_req_free - free memory used by fsf request
109 * @fsf_req: pointer to struct zfcp_fsf_req
1da177e4 110 */
c41f8cbd 111void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
1da177e4 112{
c41f8cbd
SS		 113 if (likely(req->pool)) {
114 mempool_free(req, req->pool);
dd52e0ea
HC		 115 return;
116 }
117
c41f8cbd
SS		 118 if (req->qtcb) {
119 kmem_cache_free(zfcp_data.fsf_req_qtcb_cache, req);
dd52e0ea
HC		 120 return;
121 }
1da177e4
LT		 122}
123
c41f8cbd
SS		 124/**
125 * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
126 * @adapter: pointer to struct zfcp_adapter
127 *
869b2b44
MP		 128 * Never ever call this without shutting down the adapter first.
129 * Otherwise the adapter would continue using and corrupting s390 storage.
130 * Included BUG_ON() call to ensure this is done.
131 * ERP is supposed to be the only user of this function.
1da177e4 132 */
6fcc4711 133void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
1da177e4 134{
c41f8cbd 135 struct zfcp_fsf_req *req, *tmp;
fea9d6c7 136 unsigned long flags;
6fcc4711 137 LIST_HEAD(remove_queue);
869b2b44 138 unsigned int i;
fea9d6c7 139
c41f8cbd 140 BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
fea9d6c7 141 spin_lock_irqsave(&adapter->req_list_lock, flags);
869b2b44 142 for (i = 0; i < REQUEST_LIST_SIZE; i++)
6fcc4711 143 list_splice_init(&adapter->req_list[i], &remove_queue);
fea9d6c7
VS		 144 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
145
c41f8cbd
SS		 146 list_for_each_entry_safe(req, tmp, &remove_queue, list) {
147 list_del(&req->list);
148 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
149 zfcp_fsf_req_complete(req);
1da177e4 150 }
1da177e4
LT		 151}
152
c41f8cbd 153static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
1da177e4 154{
c41f8cbd
SS		 155 struct fsf_status_read_buffer *sr_buf = req->data;
156 struct zfcp_adapter *adapter = req->adapter;
157 struct zfcp_port *port;
158 int d_id = sr_buf->d_id & ZFCP_DID_MASK;
159 unsigned long flags;
1da177e4 160
c41f8cbd
SS		 161 read_lock_irqsave(&zfcp_data.config_lock, flags);
162 list_for_each_entry(port, &adapter->port_list_head, list)
163 if (port->d_id == d_id) {
164 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
5ffd51a5 165 zfcp_erp_port_reopen(port, 0, "fssrpc1", req);
c41f8cbd
SS		 166 return;
167 }
168 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1da177e4
LT		 169}
170
5ffd51a5 171static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, char *id,
c41f8cbd 172 struct fsf_link_down_info *link_down)
aef4a983 173{
c41f8cbd 174 struct zfcp_adapter *adapter = req->adapter;
70932935 175 unsigned long flags;
698ec016 176
c41f8cbd 177 if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
ee69ab7a
MS		 178 return;
179
180 atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
70932935
CS		 181
182 read_lock_irqsave(&zfcp_data.config_lock, flags);
a2fa0aed 183 zfcp_scsi_schedule_rports_block(adapter);
70932935 184 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
ee69ab7a 185
c41f8cbd 186 if (!link_down)
2f8f3ed5 187 goto out;
ee69ab7a 188
aef4a983
MS		 189 switch (link_down->error_code) {
190 case FSF_PSQ_LINK_NO_LIGHT:
c41f8cbd 191 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 192 "There is no light signal from the local "
193 "fibre channel cable\n");
aef4a983
MS		 194 break;
195 case FSF_PSQ_LINK_WRAP_PLUG:
c41f8cbd 196 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 197 "There is a wrap plug instead of a fibre "
198 "channel cable\n");
aef4a983
MS		 199 break;
200 case FSF_PSQ_LINK_NO_FCP:
c41f8cbd 201 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 202 "The adjacent fibre channel node does not "
203 "support FCP\n");
aef4a983
MS		 204 break;
205 case FSF_PSQ_LINK_FIRMWARE_UPDATE:
c41f8cbd 206 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 207 "The FCP device is suspended because of a "
208 "firmware update\n");
553448f6 209 break;
aef4a983 210 case FSF_PSQ_LINK_INVALID_WWPN:
c41f8cbd 211 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 212 "The FCP device detected a WWPN that is "
213 "duplicate or not valid\n");
aef4a983
MS		 214 break;
215 case FSF_PSQ_LINK_NO_NPIV_SUPPORT:
c41f8cbd 216 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa 217 "The fibre channel fabric does not support NPIV\n");
aef4a983
MS		 218 break;
219 case FSF_PSQ_LINK_NO_FCP_RESOURCES:
c41f8cbd 220 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa 221 "The FCP adapter cannot support more NPIV ports\n");
aef4a983
MS		 222 break;
223 case FSF_PSQ_LINK_NO_FABRIC_RESOURCES:
c41f8cbd 224 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 225 "The adjacent switch cannot support "
226 "more NPIV ports\n");
aef4a983
MS		 227 break;
228 case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE:
c41f8cbd 229 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 230 "The FCP adapter could not log in to the "
231 "fibre channel fabric\n");
aef4a983
MS		 232 break;
233 case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED:
c41f8cbd 234 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 235 "The WWPN assignment file on the FCP adapter "
236 "has been damaged\n");
aef4a983
MS		 237 break;
238 case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED:
c41f8cbd 239 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 240 "The mode table on the FCP adapter "
241 "has been damaged\n");
aef4a983
MS		 242 break;
243 case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT:
c41f8cbd 244 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 245 "All NPIV ports on the FCP adapter have "
246 "been assigned\n");
aef4a983
MS		 247 break;
248 default:
c41f8cbd 249 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 250 "The link between the FCP adapter and "
251 "the FC fabric is down\n");
aef4a983 252 }
c41f8cbd
SS		 253out:
254 zfcp_erp_adapter_failed(adapter, id, req);
aef4a983
MS		 255}
256
c41f8cbd 257static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
1da177e4 258{
c41f8cbd
SS		 259 struct fsf_status_read_buffer *sr_buf = req->data;
260 struct fsf_link_down_info *ldi =
261 (struct fsf_link_down_info *) &sr_buf->payload;
1da177e4 262
c41f8cbd
SS		 263 switch (sr_buf->status_subtype) {
264 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
5ffd51a5 265 zfcp_fsf_link_down_info_eval(req, "fssrld1", ldi);
1da177e4 266 break;
c41f8cbd 267 case FSF_STATUS_READ_SUB_FDISC_FAILED:
5ffd51a5 268 zfcp_fsf_link_down_info_eval(req, "fssrld2", ldi);
1da177e4 269 break;
c41f8cbd 270 case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
5ffd51a5 271 zfcp_fsf_link_down_info_eval(req, "fssrld3", NULL);
c41f8cbd
SS		 272 };
273}
1da177e4 274
c41f8cbd
SS		 275static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
276{
277 struct zfcp_adapter *adapter = req->adapter;
278 struct fsf_status_read_buffer *sr_buf = req->data;
1da177e4 279
c41f8cbd
SS		 280 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
281 zfcp_hba_dbf_event_fsf_unsol("dism", adapter, sr_buf);
282 mempool_free(sr_buf, adapter->pool.data_status_read);
283 zfcp_fsf_req_free(req);
284 return;
285 }
1da177e4 286
c41f8cbd 287 zfcp_hba_dbf_event_fsf_unsol("read", adapter, sr_buf);
1da177e4 288
c41f8cbd
SS		 289 switch (sr_buf->status_type) {
290 case FSF_STATUS_READ_PORT_CLOSED:
291 zfcp_fsf_status_read_port_closed(req);
1da177e4 292 break;
c41f8cbd
SS		 293 case FSF_STATUS_READ_INCOMING_ELS:
294 zfcp_fc_incoming_els(req);
1da177e4 295 break;
c41f8cbd 296 case FSF_STATUS_READ_SENSE_DATA_AVAIL:
1da177e4 297 break;
c41f8cbd 298 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
ff3b24fa
CS		 299 dev_warn(&adapter->ccw_device->dev,
300 "The error threshold for checksum statistics "
301 "has been exceeded\n");
57069386 302 zfcp_hba_dbf_event_berr(adapter, req);
1da177e4 303 break;
c41f8cbd
SS		 304 case FSF_STATUS_READ_LINK_DOWN:
305 zfcp_fsf_status_read_link_down(req);
306 break;
307 case FSF_STATUS_READ_LINK_UP:
308 dev_info(&adapter->ccw_device->dev,
ff3b24fa 309 "The local link has been restored\n");
c41f8cbd 310 /* All ports should be marked as ready to run again */
5ffd51a5 311 zfcp_erp_modify_adapter_status(adapter, "fssrh_1", NULL,
c41f8cbd
SS		 312 ZFCP_STATUS_COMMON_RUNNING,
313 ZFCP_SET);
314 zfcp_erp_adapter_reopen(adapter,
315 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
316 ZFCP_STATUS_COMMON_ERP_FAILED,
5ffd51a5 317 "fssrh_2", req);
c41f8cbd
SS		 318 break;
319 case FSF_STATUS_READ_NOTIFICATION_LOST:
320 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_ACT_UPDATED)
5ffd51a5
SS		 321 zfcp_erp_adapter_access_changed(adapter, "fssrh_3",
322 req);
c41f8cbd
SS		 323 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
324 schedule_work(&adapter->scan_work);
325 break;
326 case FSF_STATUS_READ_CFDC_UPDATED:
5ffd51a5 327 zfcp_erp_adapter_access_changed(adapter, "fssrh_4", req);
c41f8cbd
SS		 328 break;
329 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
330 adapter->adapter_features = sr_buf->payload.word[0];
1da177e4 331 break;
1da177e4
LT		 332 }
333
c41f8cbd
SS		 334 mempool_free(sr_buf, adapter->pool.data_status_read);
335 zfcp_fsf_req_free(req);
1da177e4 336
c41f8cbd 337 atomic_inc(&adapter->stat_miss);
b7f15f3c 338 queue_work(zfcp_data.work_queue, &adapter->stat_work);
c41f8cbd 339}
1da177e4 340
c41f8cbd
SS		 341static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
342{
343 switch (req->qtcb->header.fsf_status_qual.word[0]) {
344 case FSF_SQ_FCP_RSP_AVAILABLE:
345 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
346 case FSF_SQ_NO_RETRY_POSSIBLE:
347 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
348 return;
349 case FSF_SQ_COMMAND_ABORTED:
350 req->status |= ZFCP_STATUS_FSFREQ_ABORTED;
351 break;
352 case FSF_SQ_NO_RECOM:
353 dev_err(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 354 "The FCP adapter reported a problem "
355 "that cannot be recovered\n");
5ffd51a5 356 zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1", req);
c41f8cbd
SS		 357 break;
358 }
359 /* all non-return stats set FSFREQ_ERROR*/
360 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 361}
362
c41f8cbd 363static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
1da177e4 364{
c41f8cbd
SS		 365 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
366 return;
1da177e4 367
c41f8cbd
SS		 368 switch (req->qtcb->header.fsf_status) {
369 case FSF_UNKNOWN_COMMAND:
370 dev_err(&req->adapter->ccw_device->dev,
ff3b24fa 371 "The FCP adapter does not recognize the command 0x%x\n",
c41f8cbd 372 req->qtcb->header.fsf_command);
5ffd51a5 373 zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1", req);
c41f8cbd
SS		 374 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
375 break;
376 case FSF_ADAPTER_STATUS_AVAILABLE:
377 zfcp_fsf_fsfstatus_qual_eval(req);
378 break;
379 }
380}
1da177e4 381
c41f8cbd
SS		 382static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
383{
384 struct zfcp_adapter *adapter = req->adapter;
385 struct fsf_qtcb *qtcb = req->qtcb;
386 union fsf_prot_status_qual *psq = &qtcb->prefix.prot_status_qual;
1da177e4 387
c41f8cbd 388 zfcp_hba_dbf_event_fsf_response(req);
1da177e4 389
c41f8cbd
SS		 390 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
391 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
392 ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */
393 return;
394 }
1da177e4 395
c41f8cbd
SS		 396 switch (qtcb->prefix.prot_status) {
397 case FSF_PROT_GOOD:
398 case FSF_PROT_FSF_STATUS_PRESENTED:
399 return;
400 case FSF_PROT_QTCB_VERSION_ERROR:
401 dev_err(&adapter->ccw_device->dev,
ff3b24fa
CS		 402 "QTCB version 0x%x not supported by FCP adapter "
403 "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
404 psq->word[0], psq->word[1]);
5ffd51a5 405 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1", req);
c41f8cbd
SS		 406 break;
407 case FSF_PROT_ERROR_STATE:
408 case FSF_PROT_SEQ_NUMB_ERROR:
5ffd51a5 409 zfcp_erp_adapter_reopen(adapter, 0, "fspse_2", req);
c41f8cbd
SS		 410 req->status |= ZFCP_STATUS_FSFREQ_RETRY;
411 break;
412 case FSF_PROT_UNSUPP_QTCB_TYPE:
413 dev_err(&adapter->ccw_device->dev,
ff3b24fa 414 "The QTCB type is not supported by the FCP adapter\n");
5ffd51a5 415 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3", req);
c41f8cbd
SS		 416 break;
417 case FSF_PROT_HOST_CONNECTION_INITIALIZING:
418 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
419 &adapter->status);
420 break;
421 case FSF_PROT_DUPLICATE_REQUEST_ID:
422 dev_err(&adapter->ccw_device->dev,
ff3b24fa 423 "0x%Lx is an ambiguous request identifier\n",
c41f8cbd 424 (unsigned long long)qtcb->bottom.support.req_handle);
5ffd51a5 425 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4", req);
c41f8cbd
SS		 426 break;
427 case FSF_PROT_LINK_DOWN:
5ffd51a5
SS		 428 zfcp_fsf_link_down_info_eval(req, "fspse_5",
429 &psq->link_down_info);
c41f8cbd 430 /* FIXME: reopening adapter now? better wait for link up */
5ffd51a5 431 zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req);
c41f8cbd
SS		 432 break;
433 case FSF_PROT_REEST_QUEUE:
434 /* All ports should be marked as ready to run again */
5ffd51a5 435 zfcp_erp_modify_adapter_status(adapter, "fspse_7", NULL,
c41f8cbd
SS		 436 ZFCP_STATUS_COMMON_RUNNING,
437 ZFCP_SET);
438 zfcp_erp_adapter_reopen(adapter,
439 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
5ffd51a5
SS		 440 ZFCP_STATUS_COMMON_ERP_FAILED,
441 "fspse_8", req);
c41f8cbd
SS		 442 break;
443 default:
444 dev_err(&adapter->ccw_device->dev,
ff3b24fa 445 "0x%x is not a valid transfer protocol status\n",
c41f8cbd 446 qtcb->prefix.prot_status);
5ffd51a5 447 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9", req);
c41f8cbd
SS		 448 }
449 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 450}
451
c41f8cbd
SS		 452/**
453 * zfcp_fsf_req_complete - process completion of a FSF request
454 * @fsf_req: The FSF request that has been completed.
455 *
456 * When a request has been completed either from the FCP adapter,
457 * or it has been dismissed due to a queue shutdown, this function
458 * is called to process the completion status and trigger further
459 * events related to the FSF request.
460 */
461void zfcp_fsf_req_complete(struct zfcp_fsf_req *req)
1da177e4 462{
c41f8cbd
SS		 463 if (unlikely(req->fsf_command == FSF_QTCB_UNSOLICITED_STATUS)) {
464 zfcp_fsf_status_read_handler(req);
465 return;
466 }
1da177e4 467
c41f8cbd
SS		 468 del_timer(&req->timer);
469 zfcp_fsf_protstatus_eval(req);
470 zfcp_fsf_fsfstatus_eval(req);
471 req->handler(req);
1da177e4 472
c41f8cbd 473 if (req->erp_action)
287ac01a 474 zfcp_erp_notify(req->erp_action, 0);
c41f8cbd 475 req->status |= ZFCP_STATUS_FSFREQ_COMPLETED;
1da177e4 476
c41f8cbd
SS		 477 if (likely(req->status & ZFCP_STATUS_FSFREQ_CLEANUP))
478 zfcp_fsf_req_free(req);
479 else
480 /* notify initiator waiting for the requests completion */
481 /*
482 * FIXME: Race! We must not access fsf_req here as it might have been
483 * cleaned up already due to the set ZFCP_STATUS_FSFREQ_COMPLETED
484 * flag. It's an improbable case. But, we have the same paranoia for
485 * the cleanup flag already.
486 * Might better be handled using complete()?
487 * (setting the flag and doing wakeup ought to be atomic
488 * with regard to checking the flag as long as waitqueue is
489 * part of the to be released structure)
490 */
491 wake_up(&req->completion_wq);
492}
1da177e4 493
c41f8cbd
SS		 494static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
495{
496 struct fsf_qtcb_bottom_config *bottom;
497 struct zfcp_adapter *adapter = req->adapter;
498 struct Scsi_Host *shost = adapter->scsi_host;
1da177e4 499
c41f8cbd 500 bottom = &req->qtcb->bottom.config;
1da177e4 501
c41f8cbd
SS		 502 if (req->data)
503 memcpy(req->data, bottom, sizeof(*bottom));
504
505 fc_host_node_name(shost) = bottom->nport_serv_param.wwnn;
506 fc_host_port_name(shost) = bottom->nport_serv_param.wwpn;
507 fc_host_port_id(shost) = bottom->s_id & ZFCP_DID_MASK;
508 fc_host_speed(shost) = bottom->fc_link_speed;
509 fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3;
510
511 adapter->hydra_version = bottom->adapter_type;
512 adapter->timer_ticks = bottom->timer_interval;
513
514 if (fc_host_permanent_port_name(shost) == -1)
515 fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
516
517 switch (bottom->fc_topology) {
518 case FSF_TOPO_P2P:
519 adapter->peer_d_id = bottom->peer_d_id & ZFCP_DID_MASK;
520 adapter->peer_wwpn = bottom->plogi_payload.wwpn;
521 adapter->peer_wwnn = bottom->plogi_payload.wwnn;
522 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
c41f8cbd
SS		 523 break;
524 case FSF_TOPO_FABRIC:
525 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
c41f8cbd
SS		 526 break;
527 case FSF_TOPO_AL:
528 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
dceab655 529 /* fall through */
c41f8cbd 530 default:
c41f8cbd 531 dev_err(&adapter->ccw_device->dev,
ff3b24fa
CS		 532 "Unknown or unsupported arbitrated loop "
533 "fibre channel topology detected\n");
5ffd51a5 534 zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1", req);
c41f8cbd 535 return -EIO;
1da177e4 536 }
c41f8cbd 537
1da177e4
LT		 538 return 0;
539}
540
c41f8cbd 541static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
553448f6
CS		 542{
543 struct zfcp_adapter *adapter = req->adapter;
c41f8cbd
SS		 544 struct fsf_qtcb *qtcb = req->qtcb;
545 struct fsf_qtcb_bottom_config *bottom = &qtcb->bottom.config;
546 struct Scsi_Host *shost = adapter->scsi_host;
553448f6 547
c41f8cbd
SS		 548 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
549 return;
1da177e4 550
c41f8cbd
SS		 551 adapter->fsf_lic_version = bottom->lic_version;
552 adapter->adapter_features = bottom->adapter_features;
553 adapter->connection_features = bottom->connection_features;
554 adapter->peer_wwpn = 0;
555 adapter->peer_wwnn = 0;
556 adapter->peer_d_id = 0;
8a36e453 557
c41f8cbd
SS		 558 switch (qtcb->header.fsf_status) {
559 case FSF_GOOD:
560 if (zfcp_fsf_exchange_config_evaluate(req))
561 return;
1da177e4 562
c41f8cbd
SS		 563 if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
564 dev_err(&adapter->ccw_device->dev,
ff3b24fa
CS		 565 "FCP adapter maximum QTCB size (%d bytes) "
566 "is too small\n",
567 bottom->max_qtcb_size);
5ffd51a5 568 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1", req);
c41f8cbd
SS		 569 return;
570 }
571 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
572 &adapter->status);
1da177e4 573 break;
c41f8cbd
SS		 574 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
575 fc_host_node_name(shost) = 0;
576 fc_host_port_name(shost) = 0;
577 fc_host_port_id(shost) = 0;
578 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
579 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
580 adapter->hydra_version = 0;
1da177e4 581
c41f8cbd
SS		 582 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
583 &adapter->status);
1da177e4 584
5ffd51a5 585 zfcp_fsf_link_down_info_eval(req, "fsecdh2",
c41f8cbd 586 &qtcb->header.fsf_status_qual.link_down_info);
1da177e4 587 break;
c41f8cbd 588 default:
5ffd51a5 589 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3", req);
c41f8cbd
SS		 590 return;
591 }
1da177e4 592
c41f8cbd
SS		 593 if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
594 adapter->hardware_version = bottom->hardware_version;
595 memcpy(fc_host_serial_number(shost), bottom->serial_number,
596 min(FC_SERIAL_NUMBER_SIZE, 17));
597 EBCASC(fc_host_serial_number(shost),
598 min(FC_SERIAL_NUMBER_SIZE, 17));
599 }
1da177e4 600
c41f8cbd
SS		 601 if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) {
602 dev_err(&adapter->ccw_device->dev,
ff3b24fa
CS		 603 "The FCP adapter only supports newer "
604 "control block versions\n");
5ffd51a5 605 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4", req);
c41f8cbd
SS		 606 return;
607 }
608 if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
609 dev_err(&adapter->ccw_device->dev,
ff3b24fa
CS		 610 "The FCP adapter only supports older "
611 "control block versions\n");
5ffd51a5 612 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5", req);
c41f8cbd
SS		 613 }
614}
1da177e4 615
c41f8cbd
SS		 616static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req)
617{
618 struct zfcp_adapter *adapter = req->adapter;
619 struct fsf_qtcb_bottom_port *bottom = &req->qtcb->bottom.port;
620 struct Scsi_Host *shost = adapter->scsi_host;
1da177e4 621
c41f8cbd
SS		 622 if (req->data)
623 memcpy(req->data, bottom, sizeof(*bottom));
9eb69aff 624
0282985d 625 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) {
c41f8cbd 626 fc_host_permanent_port_name(shost) = bottom->wwpn;
0282985d
CS		 627 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
628 } else
c41f8cbd
SS		 629 fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
630 fc_host_maxframe_size(shost) = bottom->maximum_frame_size;
631 fc_host_supported_speeds(shost) = bottom->supported_speed;
632}
1da177e4 633
c41f8cbd
SS		 634static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
635{
c41f8cbd
SS		 636 struct fsf_qtcb *qtcb = req->qtcb;
637
638 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
639 return;
640
641 switch (qtcb->header.fsf_status) {
642 case FSF_GOOD:
643 zfcp_fsf_exchange_port_evaluate(req);
c41f8cbd
SS		 644 break;
645 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
646 zfcp_fsf_exchange_port_evaluate(req);
5ffd51a5 647 zfcp_fsf_link_down_info_eval(req, "fsepdh1",
c41f8cbd 648 &qtcb->header.fsf_status_qual.link_down_info);
aef4a983 649 break;
1da177e4 650 }
c41f8cbd 651}
d26ab06e 652
7001f0c4 653static int zfcp_fsf_sbal_check(struct zfcp_adapter *adapter)
c41f8cbd 654{
dedbc2b3 655 struct zfcp_qdio_queue *req_q = &adapter->req_q;
c41f8cbd 656
7001f0c4
MP		 657 spin_lock_bh(&adapter->req_q_lock);
658 if (atomic_read(&req_q->count))
659 return 1;
660 spin_unlock_bh(&adapter->req_q_lock);
661 return 0;
662}
663
664static int zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter)
665{
666 long ret;
dedbc2b3 667
0406289e 668 spin_unlock_bh(&adapter->req_q_lock);
c41f8cbd 669 ret = wait_event_interruptible_timeout(adapter->request_wq,
7001f0c4 670 zfcp_fsf_sbal_check(adapter), 5 * HZ);
c41f8cbd
SS		 671 if (ret > 0)
672 return 0;
2450d3e7
SR		 673 if (!ret)
674 atomic_inc(&adapter->qdio_outb_full);
7001f0c4
MP		 675
676 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd
SS		 677 return -EIO;
678}
679
680static struct zfcp_fsf_req *zfcp_fsf_alloc_noqtcb(mempool_t *pool)
681{
682 struct zfcp_fsf_req *req;
683 req = mempool_alloc(pool, GFP_ATOMIC);
684 if (!req)
685 return NULL;
686 memset(req, 0, sizeof(*req));
88f2a977 687 req->pool = pool;
c41f8cbd
SS		 688 return req;
689}
690
691static struct zfcp_fsf_req *zfcp_fsf_alloc_qtcb(mempool_t *pool)
692{
693 struct zfcp_fsf_req_qtcb *qtcb;
694
695 if (likely(pool))
696 qtcb = mempool_alloc(pool, GFP_ATOMIC);
697 else
698 qtcb = kmem_cache_alloc(zfcp_data.fsf_req_qtcb_cache,
699 GFP_ATOMIC);
700 if (unlikely(!qtcb))
701 return NULL;
702
703 memset(qtcb, 0, sizeof(*qtcb));
704 qtcb->fsf_req.qtcb = &qtcb->qtcb;
705 qtcb->fsf_req.pool = pool;
706
707 return &qtcb->fsf_req;
708}
709
710static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_adapter *adapter,
711 u32 fsf_cmd, int req_flags,
712 mempool_t *pool)
1da177e4 713{
44cc76f2 714 struct qdio_buffer_element *sbale;
1da177e4 715
c41f8cbd
SS		 716 struct zfcp_fsf_req *req;
717 struct zfcp_qdio_queue *req_q = &adapter->req_q;
951f746f 718
c41f8cbd
SS		 719 if (req_flags & ZFCP_REQ_NO_QTCB)
720 req = zfcp_fsf_alloc_noqtcb(pool);
721 else
722 req = zfcp_fsf_alloc_qtcb(pool);
1da177e4 723
c41f8cbd 724 if (unlikely(!req))
1e9b1643 725 return ERR_PTR(-ENOMEM);
1da177e4 726
c41f8cbd
SS		 727 if (adapter->req_no == 0)
728 adapter->req_no++;
1da177e4 729
c41f8cbd
SS		 730 INIT_LIST_HEAD(&req->list);
731 init_timer(&req->timer);
732 init_waitqueue_head(&req->completion_wq);
1da177e4 733
c41f8cbd
SS		 734 req->adapter = adapter;
735 req->fsf_command = fsf_cmd;
52bfb558 736 req->req_id = adapter->req_no;
c41f8cbd
SS		 737 req->sbal_number = 1;
738 req->sbal_first = req_q->first;
739 req->sbal_last = req_q->first;
740 req->sbale_curr = 1;
741
742 sbale = zfcp_qdio_sbale_req(req);
743 sbale[0].addr = (void *) req->req_id;
744 sbale[0].flags |= SBAL_FLAGS0_COMMAND;
745
746 if (likely(req->qtcb)) {
747 req->qtcb->prefix.req_seq_no = req->adapter->fsf_req_seq_no;
748 req->qtcb->prefix.req_id = req->req_id;
749 req->qtcb->prefix.ulp_info = 26;
750 req->qtcb->prefix.qtcb_type = fsf_qtcb_type[req->fsf_command];
751 req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION;
752 req->qtcb->header.req_handle = req->req_id;
753 req->qtcb->header.fsf_command = req->fsf_command;
754 req->seq_no = adapter->fsf_req_seq_no;
755 req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
756 sbale[1].addr = (void *) req->qtcb;
757 sbale[1].length = sizeof(struct fsf_qtcb);
758 }
759
760 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)) {
761 zfcp_fsf_req_free(req);
762 return ERR_PTR(-EIO);
763 }
951f746f 764
c41f8cbd
SS		 765 if (likely(req_flags & ZFCP_REQ_AUTO_CLEANUP))
766 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1da177e4 767
c41f8cbd 768 return req;
1da177e4
LT		 769}
770
c41f8cbd
SS		 771static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
772{
773 struct zfcp_adapter *adapter = req->adapter;
135ea137
MP		 774 unsigned long flags;
775 int idx;
776 int with_qtcb = (req->qtcb != NULL);
c41f8cbd
SS		 777
778 /* put allocated FSF request into hash table */
45316a86 779 spin_lock_irqsave(&adapter->req_list_lock, flags);
c41f8cbd
SS		 780 idx = zfcp_reqlist_hash(req->req_id);
781 list_add_tail(&req->list, &adapter->req_list[idx]);
45316a86 782 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
c41f8cbd 783
3765138a 784 req->qdio_outb_usage = atomic_read(&adapter->req_q.count);
c41f8cbd
SS		 785 req->issued = get_clock();
786 if (zfcp_qdio_send(req)) {
c41f8cbd 787 del_timer(&req->timer);
3765138a
CS		 788 spin_lock_irqsave(&adapter->req_list_lock, flags);
789 /* lookup request again, list might have changed */
790 if (zfcp_reqlist_find_safe(adapter, req))
791 zfcp_reqlist_remove(adapter, req);
792 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
5ffd51a5 793 zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req);
c41f8cbd
SS		 794 return -EIO;
795 }
796
797 /* Don't increase for unsolicited status */
135ea137 798 if (with_qtcb)
c41f8cbd 799 adapter->fsf_req_seq_no++;
52bfb558 800 adapter->req_no++;
c41f8cbd
SS		 801
802 return 0;
803}
804
805/**
806 * zfcp_fsf_status_read - send status read request
807 * @adapter: pointer to struct zfcp_adapter
808 * @req_flags: request flags
809 * Returns: 0 on success, ERROR otherwise
1da177e4 810 */
c41f8cbd 811int zfcp_fsf_status_read(struct zfcp_adapter *adapter)
1da177e4 812{
c41f8cbd
SS		 813 struct zfcp_fsf_req *req;
814 struct fsf_status_read_buffer *sr_buf;
44cc76f2 815 struct qdio_buffer_element *sbale;
c41f8cbd 816 int retval = -EIO;
1da177e4 817
0406289e 818 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd
SS		 819 if (zfcp_fsf_req_sbal_get(adapter))
820 goto out;
821
822 req = zfcp_fsf_req_create(adapter, FSF_QTCB_UNSOLICITED_STATUS,
823 ZFCP_REQ_NO_QTCB,
824 adapter->pool.fsf_req_status_read);
025270f0 825 if (IS_ERR(req)) {
c41f8cbd
SS		 826 retval = PTR_ERR(req);
827 goto out;
1da177e4
LT		 828 }
829
c41f8cbd
SS		 830 sbale = zfcp_qdio_sbale_req(req);
831 sbale[0].flags |= SBAL_FLAGS0_TYPE_STATUS;
832 sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY;
833 req->sbale_curr = 2;
834
835 sr_buf = mempool_alloc(adapter->pool.data_status_read, GFP_ATOMIC);
836 if (!sr_buf) {
837 retval = -ENOMEM;
838 goto failed_buf;
839 }
840 memset(sr_buf, 0, sizeof(*sr_buf));
841 req->data = sr_buf;
842 sbale = zfcp_qdio_sbale_curr(req);
843 sbale->addr = (void *) sr_buf;
844 sbale->length = sizeof(*sr_buf);
059c97d0 845
c41f8cbd
SS		 846 retval = zfcp_fsf_req_send(req);
847 if (retval)
848 goto failed_req_send;
1da177e4 849
c41f8cbd
SS		 850 goto out;
851
852failed_req_send:
853 mempool_free(sr_buf, adapter->pool.data_status_read);
854failed_buf:
855 zfcp_fsf_req_free(req);
856 zfcp_hba_dbf_event_fsf_unsol("fail", adapter, NULL);
857out:
0406289e 858 spin_unlock_bh(&adapter->req_q_lock);
c41f8cbd
SS		 859 return retval;
860}
861
862static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
863{
864 struct zfcp_unit *unit = req->data;
865 union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual;
866
867 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
868 return;
869
870 switch (req->qtcb->header.fsf_status) {
1da177e4 871 case FSF_PORT_HANDLE_NOT_VALID:
c41f8cbd 872 if (fsq->word[0] == fsq->word[1]) {
5ffd51a5
SS		 873 zfcp_erp_adapter_reopen(unit->port->adapter, 0,
874 "fsafch1", req);
c41f8cbd 875 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 876 }
877 break;
1da177e4 878 case FSF_LUN_HANDLE_NOT_VALID:
c41f8cbd 879 if (fsq->word[0] == fsq->word[1]) {
5ffd51a5 880 zfcp_erp_port_reopen(unit->port, 0, "fsafch2", req);
c41f8cbd 881 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 882 }
883 break;
1da177e4 884 case FSF_FCP_COMMAND_DOES_NOT_EXIST:
c41f8cbd 885 req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
1da177e4 886 break;
1da177e4 887 case FSF_PORT_BOXED:
5ffd51a5 888 zfcp_erp_port_boxed(unit->port, "fsafch3", req);
c41f8cbd
SS		 889 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
890 ZFCP_STATUS_FSFREQ_RETRY;
1da177e4 891 break;
1da177e4 892 case FSF_LUN_BOXED:
5ffd51a5 893 zfcp_erp_unit_boxed(unit, "fsafch4", req);
c41f8cbd
SS		 894 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
895 ZFCP_STATUS_FSFREQ_RETRY;
1da177e4 896 break;
1da177e4 897 case FSF_ADAPTER_STATUS_AVAILABLE:
c41f8cbd 898 switch (fsq->word[0]) {
1da177e4 899 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
65a8d4e1 900 zfcp_test_link(unit->port);
dceab655 901 /* fall through */
1da177e4 902 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
c41f8cbd 903 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 904 break;
1da177e4
LT		 905 }
906 break;
1da177e4 907 case FSF_GOOD:
c41f8cbd 908 req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED;
1da177e4 909 break;
1da177e4 910 }
1da177e4
LT		 911}
912
913/**
c41f8cbd
SS		 914 * zfcp_fsf_abort_fcp_command - abort running SCSI command
915 * @old_req_id: unsigned long
c41f8cbd 916 * @unit: pointer to struct zfcp_unit
c41f8cbd 917 * Returns: pointer to struct zfcp_fsf_req
1da177e4 918 */
1da177e4 919
c41f8cbd 920struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
63caf367 921 struct zfcp_unit *unit)
1da177e4 922{
44cc76f2 923 struct qdio_buffer_element *sbale;
c41f8cbd 924 struct zfcp_fsf_req *req = NULL;
63caf367 925 struct zfcp_adapter *adapter = unit->port->adapter;
8a36e453 926
92cab0d9
CS		 927 spin_lock_bh(&adapter->req_q_lock);
928 if (zfcp_fsf_req_sbal_get(adapter))
c41f8cbd
SS		 929 goto out;
930 req = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND,
63caf367 931 0, adapter->pool.fsf_req_abort);
633528c3
SS		 932 if (IS_ERR(req)) {
933 req = NULL;
c41f8cbd 934 goto out;
633528c3 935 }
2abbe866 936
c41f8cbd
SS		 937 if (unlikely(!(atomic_read(&unit->status) &
938 ZFCP_STATUS_COMMON_UNBLOCKED)))
939 goto out_error_free;
1da177e4 940
c41f8cbd
SS		 941 sbale = zfcp_qdio_sbale_req(req);
942 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
943 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1da177e4 944
c41f8cbd
SS		 945 req->data = unit;
946 req->handler = zfcp_fsf_abort_fcp_command_handler;
947 req->qtcb->header.lun_handle = unit->handle;
948 req->qtcb->header.port_handle = unit->port->handle;
949 req->qtcb->bottom.support.req_handle = (u64) old_req_id;
950
951 zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
952 if (!zfcp_fsf_req_send(req))
953 goto out;
954
955out_error_free:
956 zfcp_fsf_req_free(req);
957 req = NULL;
958out:
92cab0d9 959 spin_unlock_bh(&adapter->req_q_lock);
c41f8cbd 960 return req;
1da177e4
LT		 961}
962
c41f8cbd 963static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
1da177e4 964{
c41f8cbd
SS		 965 struct zfcp_adapter *adapter = req->adapter;
966 struct zfcp_send_ct *send_ct = req->data;
c41f8cbd 967 struct fsf_qtcb_header *header = &req->qtcb->header;
1da177e4 968
c41f8cbd 969 send_ct->status = -EINVAL;
1da177e4 970
c41f8cbd 971 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1da177e4
LT		 972 goto skip_fsfstatus;
973
1da177e4 974 switch (header->fsf_status) {
1da177e4 975 case FSF_GOOD:
c41f8cbd
SS		 976 zfcp_san_dbf_event_ct_response(req);
977 send_ct->status = 0;
1da177e4 978 break;
1da177e4 979 case FSF_SERVICE_CLASS_NOT_SUPPORTED:
c41f8cbd 980 zfcp_fsf_class_not_supp(req);
1da177e4 981 break;
1da177e4 982 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 983 switch (header->fsf_status_qual.word[0]){
984 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1da177e4 985 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
c41f8cbd 986 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 987 break;
1da177e4
LT		 988 }
989 break;
1da177e4 990 case FSF_ACCESS_DENIED:
1da177e4 991 break;
1da177e4 992 case FSF_PORT_BOXED:
c41f8cbd
SS		 993 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
994 ZFCP_STATUS_FSFREQ_RETRY;
1da177e4 995 break;
c41f8cbd 996 case FSF_PORT_HANDLE_NOT_VALID:
5ffd51a5 997 zfcp_erp_adapter_reopen(adapter, 0, "fsscth1", req);
dceab655 998 /* fall through */
c41f8cbd 999 case FSF_GENERIC_COMMAND_REJECTED:
1da177e4 1000 case FSF_PAYLOAD_SIZE_MISMATCH:
1da177e4 1001 case FSF_REQUEST_SIZE_TOO_LARGE:
1da177e4 1002 case FSF_RESPONSE_SIZE_TOO_LARGE:
1da177e4 1003 case FSF_SBAL_MISMATCH:
c41f8cbd 1004 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 1005 break;
1006 }
1007
1008skip_fsfstatus:
c41f8cbd 1009 if (send_ct->handler)
1da177e4 1010 send_ct->handler(send_ct->handler_data);
c41f8cbd 1011}
1da177e4 1012
39eb7e9a
CS		 1013static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
1014 struct scatterlist *sg_req,
1015 struct scatterlist *sg_resp,
1016 int max_sbals)
c41f8cbd 1017{
39eb7e9a
CS		 1018 struct qdio_buffer_element *sbale = zfcp_qdio_sbale_req(req);
1019 u32 feat = req->adapter->adapter_features;
c41f8cbd
SS		 1020 int bytes;
1021
39eb7e9a
CS		 1022 if (!(feat & FSF_FEATURE_ELS_CT_CHAINED_SBALS)) {
1023 if (sg_req->length > PAGE_SIZE || sg_resp->length > PAGE_SIZE ||
1024 !sg_is_last(sg_req) || !sg_is_last(sg_resp))
1025 return -EOPNOTSUPP;
1026
1027 sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE_READ;
1028 sbale[2].addr = sg_virt(sg_req);
1029 sbale[2].length = sg_req->length;
1030 sbale[3].addr = sg_virt(sg_resp);
1031 sbale[3].length = sg_resp->length;
1032 sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY;
1033 return 0;
1034 }
1035
c41f8cbd
SS		 1036 bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ,
1037 sg_req, max_sbals);
1038 if (bytes <= 0)
1039 return -ENOMEM;
1040 req->qtcb->bottom.support.req_buf_length = bytes;
1041 req->sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
1042
1043 bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ,
1044 sg_resp, max_sbals);
1045 if (bytes <= 0)
1046 return -ENOMEM;
1047 req->qtcb->bottom.support.resp_buf_length = bytes;
1048
1049 return 0;
1da177e4
LT		 1050}
1051
1052/**
c41f8cbd
SS		 1053 * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
1054 * @ct: pointer to struct zfcp_send_ct with data for request
1055 * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
1056 * @erp_action: if non-null the Generic Service request sent within ERP
1da177e4 1057 */
c41f8cbd
SS		 1058int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool,
1059 struct zfcp_erp_action *erp_action)
1da177e4 1060{
5ab944f9
SS		 1061 struct zfcp_wka_port *wka_port = ct->wka_port;
1062 struct zfcp_adapter *adapter = wka_port->adapter;
c41f8cbd
SS		 1063 struct zfcp_fsf_req *req;
1064 int ret = -EIO;
1da177e4 1065
0406289e 1066 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd
SS		 1067 if (zfcp_fsf_req_sbal_get(adapter))
1068 goto out;
1da177e4 1069
c41f8cbd
SS		 1070 req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_GENERIC,
1071 ZFCP_REQ_AUTO_CLEANUP, pool);
025270f0 1072 if (IS_ERR(req)) {
c41f8cbd
SS		 1073 ret = PTR_ERR(req);
1074 goto out;
3f0ca62a
CS		 1075 }
1076
39eb7e9a
CS		 1077 ret = zfcp_fsf_setup_ct_els_sbals(req, ct->req, ct->resp,
1078 FSF_MAX_SBALS_PER_REQ);
553448f6 1079 if (ret)
1da177e4 1080 goto failed_send;
1da177e4 1081
c41f8cbd 1082 req->handler = zfcp_fsf_send_ct_handler;
5ab944f9 1083 req->qtcb->header.port_handle = wka_port->handle;
c41f8cbd
SS		 1084 req->qtcb->bottom.support.service_class = FSF_CLASS_3;
1085 req->qtcb->bottom.support.timeout = ct->timeout;
1086 req->data = ct;
1087
1088 zfcp_san_dbf_event_ct_request(req);
1089
1090 if (erp_action) {
1091 erp_action->fsf_req = req;
1092 req->erp_action = erp_action;
287ac01a 1093 zfcp_fsf_start_erp_timer(req);
c41f8cbd
SS		 1094 } else
1095 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1da177e4 1096
c41f8cbd
SS		 1097 ret = zfcp_fsf_req_send(req);
1098 if (ret)
1099 goto failed_send;
1da177e4 1100
c41f8cbd 1101 goto out;
1da177e4 1102
c41f8cbd
SS		 1103failed_send:
1104 zfcp_fsf_req_free(req);
1105 if (erp_action)
1106 erp_action->fsf_req = NULL;
1107out:
0406289e 1108 spin_unlock_bh(&adapter->req_q_lock);
c41f8cbd 1109 return ret;
1da177e4
LT		 1110}
1111
c41f8cbd 1112static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
1da177e4 1113{
c41f8cbd
SS		 1114 struct zfcp_send_els *send_els = req->data;
1115 struct zfcp_port *port = send_els->port;
1116 struct fsf_qtcb_header *header = &req->qtcb->header;
1da177e4 1117
c41f8cbd 1118 send_els->status = -EINVAL;
1da177e4 1119
c41f8cbd 1120 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1da177e4
LT		 1121 goto skip_fsfstatus;
1122
1123 switch (header->fsf_status) {
1da177e4 1124 case FSF_GOOD:
c41f8cbd
SS		 1125 zfcp_san_dbf_event_els_response(req);
1126 send_els->status = 0;
1da177e4 1127 break;
1da177e4 1128 case FSF_SERVICE_CLASS_NOT_SUPPORTED:
c41f8cbd 1129 zfcp_fsf_class_not_supp(req);
1da177e4 1130 break;
1da177e4 1131 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 1132 switch (header->fsf_status_qual.word[0]){
1133 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
64b29a13
AH		 1134 if (port && (send_els->ls_code != ZFCP_LS_ADISC))
1135 zfcp_test_link(port);
c41f8cbd 1136 /*fall through */
1da177e4 1137 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1da177e4 1138 case FSF_SQ_RETRY_IF_POSSIBLE:
c41f8cbd 1139 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1140 break;
1da177e4
LT		 1141 }
1142 break;
1da177e4 1143 case FSF_ELS_COMMAND_REJECTED:
1da177e4 1144 case FSF_PAYLOAD_SIZE_MISMATCH:
1da177e4 1145 case FSF_REQUEST_SIZE_TOO_LARGE:
1da177e4 1146 case FSF_RESPONSE_SIZE_TOO_LARGE:
1da177e4 1147 break;
1da177e4 1148 case FSF_ACCESS_DENIED:
dc577d55
CS		 1149 if (port)
1150 zfcp_fsf_access_denied_port(req, port);
1da177e4 1151 break;
c41f8cbd
SS		 1152 case FSF_SBAL_MISMATCH:
1153 /* should never occure, avoided in zfcp_fsf_send_els */
1154 /* fall through */
1da177e4 1155 default:
c41f8cbd 1156 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 1157 break;
1158 }
1da177e4 1159skip_fsfstatus:
aa551daf 1160 if (send_els->handler)
1da177e4 1161 send_els->handler(send_els->handler_data);
c41f8cbd 1162}
1da177e4 1163
c41f8cbd
SS		 1164/**
1165 * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
1166 * @els: pointer to struct zfcp_send_els with data for the command
1167 */
1168int zfcp_fsf_send_els(struct zfcp_send_els *els)
1169{
1170 struct zfcp_fsf_req *req;
1171 struct zfcp_adapter *adapter = els->adapter;
1172 struct fsf_qtcb_bottom_support *bottom;
1173 int ret = -EIO;
1174
8fdf30d5
CS		 1175 spin_lock_bh(&adapter->req_q_lock);
1176 if (zfcp_fsf_req_sbal_get(adapter))
c41f8cbd
SS		 1177 goto out;
1178 req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS,
1179 ZFCP_REQ_AUTO_CLEANUP, NULL);
025270f0 1180 if (IS_ERR(req)) {
c41f8cbd
SS		 1181 ret = PTR_ERR(req);
1182 goto out;
1183 }
1184
39eb7e9a 1185 ret = zfcp_fsf_setup_ct_els_sbals(req, els->req, els->resp, 2);
44cc76f2 1186
c41f8cbd
SS		 1187 if (ret)
1188 goto failed_send;
1189
1190 bottom = &req->qtcb->bottom.support;
1191 req->handler = zfcp_fsf_send_els_handler;
1192 bottom->d_id = els->d_id;
1193 bottom->service_class = FSF_CLASS_3;
1194 bottom->timeout = 2 * R_A_TOV;
1195 req->data = els;
1196
1197 zfcp_san_dbf_event_els_request(req);
1198
1199 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1200 ret = zfcp_fsf_req_send(req);
1201 if (ret)
1202 goto failed_send;
1203
1204 goto out;
1205
1206failed_send:
1207 zfcp_fsf_req_free(req);
1208out:
8fdf30d5 1209 spin_unlock_bh(&adapter->req_q_lock);
c41f8cbd 1210 return ret;
1da177e4
LT		 1211}
1212
c41f8cbd 1213int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
1da177e4 1214{
44cc76f2 1215 struct qdio_buffer_element *sbale;
c41f8cbd 1216 struct zfcp_fsf_req *req;
52ef11a7 1217 struct zfcp_adapter *adapter = erp_action->adapter;
c41f8cbd
SS		 1218 int retval = -EIO;
1219
0406289e 1220 spin_lock_bh(&adapter->req_q_lock);
92cab0d9 1221 if (zfcp_fsf_req_sbal_get(adapter))
c41f8cbd
SS		 1222 goto out;
1223 req = zfcp_fsf_req_create(adapter,
1224 FSF_QTCB_EXCHANGE_CONFIG_DATA,
1225 ZFCP_REQ_AUTO_CLEANUP,
1226 adapter->pool.fsf_req_erp);
025270f0 1227 if (IS_ERR(req)) {
c41f8cbd
SS		 1228 retval = PTR_ERR(req);
1229 goto out;
1da177e4
LT		 1230 }
1231
c41f8cbd 1232 sbale = zfcp_qdio_sbale_req(req);
52ef11a7
SS		 1233 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1234 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1da177e4 1235
c41f8cbd 1236 req->qtcb->bottom.config.feature_selection =
aef4a983
MS		 1237 FSF_FEATURE_CFDC |
1238 FSF_FEATURE_LUN_SHARING |
9eb69aff 1239 FSF_FEATURE_NOTIFICATION_LOST |
aef4a983 1240 FSF_FEATURE_UPDATE_ALERT;
c41f8cbd
SS		 1241 req->erp_action = erp_action;
1242 req->handler = zfcp_fsf_exchange_config_data_handler;
1243 erp_action->fsf_req = req;
1da177e4 1244
287ac01a 1245 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1246 retval = zfcp_fsf_req_send(req);
1da177e4 1247 if (retval) {
c41f8cbd 1248 zfcp_fsf_req_free(req);
1da177e4 1249 erp_action->fsf_req = NULL;
1da177e4 1250 }
c41f8cbd 1251out:
0406289e 1252 spin_unlock_bh(&adapter->req_q_lock);
52ef11a7
SS		 1253 return retval;
1254}
1da177e4 1255
c41f8cbd
SS		 1256int zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter,
1257 struct fsf_qtcb_bottom_config *data)
52ef11a7 1258{
44cc76f2 1259 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 1260 struct zfcp_fsf_req *req = NULL;
1261 int retval = -EIO;
1262
0406289e 1263 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd 1264 if (zfcp_fsf_req_sbal_get(adapter))
ada81b74 1265 goto out_unlock;
c41f8cbd
SS		 1266
1267 req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_CONFIG_DATA,
1268 0, NULL);
025270f0 1269 if (IS_ERR(req)) {
c41f8cbd 1270 retval = PTR_ERR(req);
ada81b74 1271 goto out_unlock;
52ef11a7
SS		 1272 }
1273
c41f8cbd 1274 sbale = zfcp_qdio_sbale_req(req);
52ef11a7
SS		 1275 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1276 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
c41f8cbd 1277 req->handler = zfcp_fsf_exchange_config_data_handler;
52ef11a7 1278
c41f8cbd 1279 req->qtcb->bottom.config.feature_selection =
52ef11a7
SS		 1280 FSF_FEATURE_CFDC |
1281 FSF_FEATURE_LUN_SHARING |
1282 FSF_FEATURE_NOTIFICATION_LOST |
1283 FSF_FEATURE_UPDATE_ALERT;
1284
1285 if (data)
c41f8cbd 1286 req->data = data;
52ef11a7 1287
c41f8cbd
SS		 1288 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1289 retval = zfcp_fsf_req_send(req);
0406289e 1290 spin_unlock_bh(&adapter->req_q_lock);
553448f6 1291 if (!retval)
c41f8cbd
SS		 1292 wait_event(req->completion_wq,
1293 req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
52ef11a7 1294
c41f8cbd 1295 zfcp_fsf_req_free(req);
ada81b74 1296 return retval;
52ef11a7 1297
ada81b74
CS		 1298out_unlock:
1299 spin_unlock_bh(&adapter->req_q_lock);
1da177e4
LT		 1300 return retval;
1301}
1302
1da177e4
LT		 1303/**
1304 * zfcp_fsf_exchange_port_data - request information about local port
aef4a983 1305 * @erp_action: ERP action for the adapter for which port data is requested
c41f8cbd 1306 * Returns: 0 on success, error otherwise
1da177e4 1307 */
c41f8cbd 1308int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
1da177e4 1309{
44cc76f2 1310 struct qdio_buffer_element *sbale;
c41f8cbd 1311 struct zfcp_fsf_req *req;
52ef11a7 1312 struct zfcp_adapter *adapter = erp_action->adapter;
c41f8cbd 1313 int retval = -EIO;
1da177e4 1314
553448f6 1315 if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
52ef11a7 1316 return -EOPNOTSUPP;
1da177e4 1317
0406289e 1318 spin_lock_bh(&adapter->req_q_lock);
92cab0d9 1319 if (zfcp_fsf_req_sbal_get(adapter))
c41f8cbd
SS		 1320 goto out;
1321 req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA,
1322 ZFCP_REQ_AUTO_CLEANUP,
1323 adapter->pool.fsf_req_erp);
025270f0 1324 if (IS_ERR(req)) {
c41f8cbd
SS		 1325 retval = PTR_ERR(req);
1326 goto out;
aef4a983
MS		 1327 }
1328
c41f8cbd 1329 sbale = zfcp_qdio_sbale_req(req);
52ef11a7
SS		 1330 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1331 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1da177e4 1332
c41f8cbd
SS		 1333 req->handler = zfcp_fsf_exchange_port_data_handler;
1334 req->erp_action = erp_action;
1335 erp_action->fsf_req = req;
52ef11a7 1336
287ac01a 1337 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1338 retval = zfcp_fsf_req_send(req);
1da177e4 1339 if (retval) {
c41f8cbd 1340 zfcp_fsf_req_free(req);
52ef11a7
SS		 1341 erp_action->fsf_req = NULL;
1342 }
c41f8cbd 1343out:
0406289e 1344 spin_unlock_bh(&adapter->req_q_lock);
52ef11a7
SS		 1345 return retval;
1346}
1347
52ef11a7
SS		 1348/**
1349 * zfcp_fsf_exchange_port_data_sync - request information about local port
c41f8cbd
SS		 1350 * @adapter: pointer to struct zfcp_adapter
1351 * @data: pointer to struct fsf_qtcb_bottom_port
1352 * Returns: 0 on success, error otherwise
52ef11a7 1353 */
c41f8cbd
SS		 1354int zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter *adapter,
1355 struct fsf_qtcb_bottom_port *data)
52ef11a7 1356{
44cc76f2 1357 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 1358 struct zfcp_fsf_req *req = NULL;
1359 int retval = -EIO;
52ef11a7 1360
553448f6 1361 if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
52ef11a7 1362 return -EOPNOTSUPP;
52ef11a7 1363
0406289e 1364 spin_lock_bh(&adapter->req_q_lock);
92cab0d9 1365 if (zfcp_fsf_req_sbal_get(adapter))
ada81b74 1366 goto out_unlock;
c41f8cbd
SS		 1367
1368 req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA, 0,
1369 NULL);
025270f0 1370 if (IS_ERR(req)) {
c41f8cbd 1371 retval = PTR_ERR(req);
ada81b74 1372 goto out_unlock;
1da177e4
LT		 1373 }
1374
52ef11a7 1375 if (data)
c41f8cbd 1376 req->data = data;
52ef11a7 1377
c41f8cbd 1378 sbale = zfcp_qdio_sbale_req(req);
52ef11a7
SS		 1379 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1380 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1381
c41f8cbd
SS		 1382 req->handler = zfcp_fsf_exchange_port_data_handler;
1383 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1384 retval = zfcp_fsf_req_send(req);
0406289e 1385 spin_unlock_bh(&adapter->req_q_lock);
ada81b74 1386
553448f6 1387 if (!retval)
c41f8cbd
SS		 1388 wait_event(req->completion_wq,
1389 req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
1390 zfcp_fsf_req_free(req);
1da177e4 1391
1da177e4 1392 return retval;
ada81b74
CS		 1393
1394out_unlock:
1395 spin_unlock_bh(&adapter->req_q_lock);
1396 return retval;
1da177e4
LT		 1397}
1398
c41f8cbd 1399static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
1da177e4 1400{
c41f8cbd
SS		 1401 struct zfcp_port *port = req->data;
1402 struct fsf_qtcb_header *header = &req->qtcb->header;
1da177e4 1403 struct fsf_plogi *plogi;
1da177e4 1404
c41f8cbd 1405 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
a17c5855 1406 goto out;
1da177e4 1407
1da177e4 1408 switch (header->fsf_status) {
1da177e4 1409 case FSF_PORT_ALREADY_OPEN:
1da177e4 1410 break;
1da177e4 1411 case FSF_ACCESS_DENIED:
c41f8cbd 1412 zfcp_fsf_access_denied_port(req, port);
1da177e4 1413 break;
1da177e4 1414 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
c41f8cbd 1415 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa 1416 "Not enough FCP adapter resources to open "
7ba58c9c
SS		 1417 "remote port 0x%016Lx\n",
1418 (unsigned long long)port->wwpn);
5ffd51a5 1419 zfcp_erp_port_failed(port, "fsoph_1", req);
c41f8cbd 1420 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1421 break;
1da177e4 1422 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 1423 switch (header->fsf_status_qual.word[0]) {
1424 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1da177e4 1425 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1da177e4 1426 case FSF_SQ_NO_RETRY_POSSIBLE:
c41f8cbd 1427 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 1428 break;
1429 }
1430 break;
1da177e4 1431 case FSF_GOOD:
1da177e4 1432 port->handle = header->port_handle;
1da177e4
LT		 1433 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN |
1434 ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
d736a27b
AH		 1435 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1436 ZFCP_STATUS_COMMON_ACCESS_BOXED,
1437 &port->status);
1da177e4
LT		 1438 /* check whether D_ID has changed during open */
1439 /*
1440 * FIXME: This check is not airtight, as the FCP channel does
1441 * not monitor closures of target port connections caused on
1442 * the remote side. Thus, they might miss out on invalidating
1443 * locally cached WWPNs (and other N_Port parameters) of gone
1444 * target ports. So, our heroic attempt to make things safe
1445 * could be undermined by 'open port' response data tagged with
1446 * obsolete WWPNs. Another reason to monitor potential
1447 * connection closures ourself at least (by interpreting
1448 * incoming ELS' and unsolicited status). It just crosses my
1449 * mind that one should be able to cross-check by means of
1450 * another GID_PN straight after a port has been opened.
1451 * Alternately, an ADISC/PDISC ELS should suffice, as well.
1452 */
c41f8cbd 1453 plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els;
39eb7e9a
CS		 1454 if (req->qtcb->bottom.support.els1_length >=
1455 FSF_PLOGI_MIN_LEN) {
c41f8cbd 1456 if (plogi->serv_param.wwpn != port->wwpn)
b98478d7 1457 port->d_id = 0;
c41f8cbd
SS		 1458 else {
1459 port->wwnn = plogi->serv_param.wwnn;
1460 zfcp_fc_plogi_evaluate(port, plogi);
1da177e4
LT		 1461 }
1462 }
1463 break;
1da177e4 1464 case FSF_UNKNOWN_OP_SUBTYPE:
c41f8cbd 1465 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 1466 break;
1467 }
a17c5855
MP		 1468
1469out:
1470 zfcp_port_put(port);
1da177e4
LT		 1471}
1472
c41f8cbd
SS		 1473/**
1474 * zfcp_fsf_open_port - create and send open port request
1475 * @erp_action: pointer to struct zfcp_erp_action
1476 * Returns: 0 on success, error otherwise
1da177e4 1477 */
c41f8cbd 1478int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
1da177e4 1479{
44cc76f2 1480 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 1481 struct zfcp_adapter *adapter = erp_action->adapter;
1482 struct zfcp_fsf_req *req;
a17c5855 1483 struct zfcp_port *port = erp_action->port;
c41f8cbd
SS		 1484 int retval = -EIO;
1485
0406289e 1486 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd
SS		 1487 if (zfcp_fsf_req_sbal_get(adapter))
1488 goto out;
1489
1490 req = zfcp_fsf_req_create(adapter,
1491 FSF_QTCB_OPEN_PORT_WITH_DID,
1492 ZFCP_REQ_AUTO_CLEANUP,
1493 adapter->pool.fsf_req_erp);
025270f0 1494 if (IS_ERR(req)) {
c41f8cbd 1495 retval = PTR_ERR(req);
1da177e4 1496 goto out;
c41f8cbd 1497 }
1da177e4 1498
c41f8cbd 1499 sbale = zfcp_qdio_sbale_req(req);
1da177e4
LT		 1500 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1501 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1502
c41f8cbd 1503 req->handler = zfcp_fsf_open_port_handler;
a17c5855
MP		 1504 req->qtcb->bottom.support.d_id = port->d_id;
1505 req->data = port;
c41f8cbd
SS		 1506 req->erp_action = erp_action;
1507 erp_action->fsf_req = req;
a17c5855 1508 zfcp_port_get(port);
c41f8cbd 1509
287ac01a 1510 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1511 retval = zfcp_fsf_req_send(req);
1da177e4 1512 if (retval) {
c41f8cbd 1513 zfcp_fsf_req_free(req);
1da177e4 1514 erp_action->fsf_req = NULL;
a17c5855 1515 zfcp_port_put(port);
1da177e4 1516 }
c41f8cbd 1517out:
0406289e 1518 spin_unlock_bh(&adapter->req_q_lock);
1da177e4
LT		 1519 return retval;
1520}
1521
c41f8cbd 1522static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
1da177e4 1523{
c41f8cbd 1524 struct zfcp_port *port = req->data;
1da177e4 1525
c41f8cbd 1526 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
44cc76f2 1527 return;
1da177e4 1528
c41f8cbd 1529 switch (req->qtcb->header.fsf_status) {
1da177e4 1530 case FSF_PORT_HANDLE_NOT_VALID:
5ffd51a5 1531 zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1", req);
c41f8cbd 1532 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1533 break;
1da177e4 1534 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4 1535 break;
1da177e4 1536 case FSF_GOOD:
5ffd51a5 1537 zfcp_erp_modify_port_status(port, "fscph_2", req,
1da177e4
LT		 1538 ZFCP_STATUS_COMMON_OPEN,
1539 ZFCP_CLEAR);
1da177e4 1540 break;
1da177e4 1541 }
1da177e4
LT		 1542}
1543
c41f8cbd
SS		 1544/**
1545 * zfcp_fsf_close_port - create and send close port request
1546 * @erp_action: pointer to struct zfcp_erp_action
1547 * Returns: 0 on success, error otherwise
1da177e4 1548 */
c41f8cbd 1549int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
1da177e4 1550{
44cc76f2 1551 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 1552 struct zfcp_adapter *adapter = erp_action->adapter;
1553 struct zfcp_fsf_req *req;
1554 int retval = -EIO;
1555
0406289e 1556 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd
SS		 1557 if (zfcp_fsf_req_sbal_get(adapter))
1558 goto out;
1559
1560 req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT,
1561 ZFCP_REQ_AUTO_CLEANUP,
1562 adapter->pool.fsf_req_erp);
025270f0 1563 if (IS_ERR(req)) {
c41f8cbd 1564 retval = PTR_ERR(req);
1da177e4 1565 goto out;
c41f8cbd 1566 }
1da177e4 1567
c41f8cbd 1568 sbale = zfcp_qdio_sbale_req(req);
1da177e4
LT		 1569 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1570 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1571
c41f8cbd
SS		 1572 req->handler = zfcp_fsf_close_port_handler;
1573 req->data = erp_action->port;
1574 req->erp_action = erp_action;
1575 req->qtcb->header.port_handle = erp_action->port->handle;
1576 erp_action->fsf_req = req;
c41f8cbd 1577
287ac01a 1578 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1579 retval = zfcp_fsf_req_send(req);
1da177e4 1580 if (retval) {
c41f8cbd 1581 zfcp_fsf_req_free(req);
1da177e4 1582 erp_action->fsf_req = NULL;
1da177e4 1583 }
c41f8cbd 1584out:
0406289e 1585 spin_unlock_bh(&adapter->req_q_lock);
1da177e4
LT		 1586 return retval;
1587}
1588
5ab944f9
SS		 1589static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
1590{
1591 struct zfcp_wka_port *wka_port = req->data;
1592 struct fsf_qtcb_header *header = &req->qtcb->header;
1593
1594 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
1595 wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1596 goto out;
1597 }
1598
1599 switch (header->fsf_status) {
1600 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
1601 dev_warn(&req->adapter->ccw_device->dev,
1602 "Opening WKA port 0x%x failed\n", wka_port->d_id);
dceab655 1603 /* fall through */
5ab944f9
SS		 1604 case FSF_ADAPTER_STATUS_AVAILABLE:
1605 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
dceab655 1606 /* fall through */
5ab944f9
SS		 1607 case FSF_ACCESS_DENIED:
1608 wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1609 break;
1610 case FSF_PORT_ALREADY_OPEN:
1c1cba17 1611 break;
5ab944f9
SS		 1612 case FSF_GOOD:
1613 wka_port->handle = header->port_handle;
1614 wka_port->status = ZFCP_WKA_PORT_ONLINE;
1615 }
1616out:
1617 wake_up(&wka_port->completion_wq);
1618}
1619
1620/**
1621 * zfcp_fsf_open_wka_port - create and send open wka-port request
1622 * @wka_port: pointer to struct zfcp_wka_port
1623 * Returns: 0 on success, error otherwise
1624 */
1625int zfcp_fsf_open_wka_port(struct zfcp_wka_port *wka_port)
1626{
1627 struct qdio_buffer_element *sbale;
1628 struct zfcp_adapter *adapter = wka_port->adapter;
1629 struct zfcp_fsf_req *req;
1630 int retval = -EIO;
1631
0406289e 1632 spin_lock_bh(&adapter->req_q_lock);
5ab944f9
SS		 1633 if (zfcp_fsf_req_sbal_get(adapter))
1634 goto out;
1635
1636 req = zfcp_fsf_req_create(adapter,
1637 FSF_QTCB_OPEN_PORT_WITH_DID,
1638 ZFCP_REQ_AUTO_CLEANUP,
1639 adapter->pool.fsf_req_erp);
1640 if (unlikely(IS_ERR(req))) {
1641 retval = PTR_ERR(req);
1642 goto out;
1643 }
1644
1645 sbale = zfcp_qdio_sbale_req(req);
1646 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1647 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1648
1649 req->handler = zfcp_fsf_open_wka_port_handler;
1650 req->qtcb->bottom.support.d_id = wka_port->d_id;
1651 req->data = wka_port;
1652
1653 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1654 retval = zfcp_fsf_req_send(req);
1655 if (retval)
1656 zfcp_fsf_req_free(req);
1657out:
0406289e 1658 spin_unlock_bh(&adapter->req_q_lock);
5ab944f9
SS		 1659 return retval;
1660}
1661
1662static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
1663{
1664 struct zfcp_wka_port *wka_port = req->data;
1665
1666 if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
1667 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
5ffd51a5 1668 zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1", req);
5ab944f9
SS		 1669 }
1670
1671 wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1672 wake_up(&wka_port->completion_wq);
1673}
1674
1675/**
1676 * zfcp_fsf_close_wka_port - create and send close wka port request
1677 * @erp_action: pointer to struct zfcp_erp_action
1678 * Returns: 0 on success, error otherwise
1679 */
1680int zfcp_fsf_close_wka_port(struct zfcp_wka_port *wka_port)
1681{
1682 struct qdio_buffer_element *sbale;
1683 struct zfcp_adapter *adapter = wka_port->adapter;
1684 struct zfcp_fsf_req *req;
1685 int retval = -EIO;
1686
0406289e 1687 spin_lock_bh(&adapter->req_q_lock);
5ab944f9
SS		 1688 if (zfcp_fsf_req_sbal_get(adapter))
1689 goto out;
1690
1691 req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT,
1692 ZFCP_REQ_AUTO_CLEANUP,
1693 adapter->pool.fsf_req_erp);
1694 if (unlikely(IS_ERR(req))) {
1695 retval = PTR_ERR(req);
1696 goto out;
1697 }
1698
1699 sbale = zfcp_qdio_sbale_req(req);
1700 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1701 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1702
1703 req->handler = zfcp_fsf_close_wka_port_handler;
1704 req->data = wka_port;
1705 req->qtcb->header.port_handle = wka_port->handle;
1706
1707 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1708 retval = zfcp_fsf_req_send(req);
1709 if (retval)
1710 zfcp_fsf_req_free(req);
1711out:
0406289e 1712 spin_unlock_bh(&adapter->req_q_lock);
5ab944f9
SS		 1713 return retval;
1714}
1715
c41f8cbd 1716static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
1da177e4 1717{
c41f8cbd
SS		 1718 struct zfcp_port *port = req->data;
1719 struct fsf_qtcb_header *header = &req->qtcb->header;
1da177e4 1720 struct zfcp_unit *unit;
1da177e4 1721
c41f8cbd 1722 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
a5b11dda 1723 return;
1da177e4 1724
1da177e4 1725 switch (header->fsf_status) {
1da177e4 1726 case FSF_PORT_HANDLE_NOT_VALID:
5ffd51a5 1727 zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1", req);
c41f8cbd 1728 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1729 break;
1da177e4 1730 case FSF_ACCESS_DENIED:
c41f8cbd 1731 zfcp_fsf_access_denied_port(req, port);
1da177e4 1732 break;
1da177e4 1733 case FSF_PORT_BOXED:
5c815d15
CS		 1734 /* can't use generic zfcp_erp_modify_port_status because
1735 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
1736 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1737 list_for_each_entry(unit, &port->unit_list_head, list)
1738 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1739 &unit->status);
dfb3cf00
SS		 1740 zfcp_erp_port_boxed(port, "fscpph2", req);
1741 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1742 ZFCP_STATUS_FSFREQ_RETRY;
1743
1da177e4 1744 break;
1da177e4 1745 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 1746 switch (header->fsf_status_qual.word[0]) {
1747 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
c41f8cbd 1748 /* fall through */
1da177e4 1749 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
c41f8cbd 1750 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1751 break;
1da177e4
LT		 1752 }
1753 break;
1da177e4 1754 case FSF_GOOD:
1da177e4
LT		 1755 /* can't use generic zfcp_erp_modify_port_status because
1756 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
1757 */
1758 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1759 list_for_each_entry(unit, &port->unit_list_head, list)
c41f8cbd
SS		 1760 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1761 &unit->status);
1da177e4 1762 break;
1da177e4 1763 }
1da177e4
LT		 1764}
1765
c41f8cbd
SS		 1766/**
1767 * zfcp_fsf_close_physical_port - close physical port
1768 * @erp_action: pointer to struct zfcp_erp_action
1769 * Returns: 0 on success
1da177e4 1770 */
c41f8cbd 1771int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
1da177e4 1772{
44cc76f2 1773 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 1774 struct zfcp_adapter *adapter = erp_action->adapter;
1775 struct zfcp_fsf_req *req;
1776 int retval = -EIO;
1777
0406289e 1778 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd 1779 if (zfcp_fsf_req_sbal_get(adapter))
1da177e4 1780 goto out;
1da177e4 1781
c41f8cbd
SS		 1782 req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PHYSICAL_PORT,
1783 ZFCP_REQ_AUTO_CLEANUP,
1784 adapter->pool.fsf_req_erp);
025270f0 1785 if (IS_ERR(req)) {
c41f8cbd
SS		 1786 retval = PTR_ERR(req);
1787 goto out;
1788 }
1da177e4 1789
c41f8cbd
SS		 1790 sbale = zfcp_qdio_sbale_req(req);
1791 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1792 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1da177e4 1793
c41f8cbd
SS		 1794 req->data = erp_action->port;
1795 req->qtcb->header.port_handle = erp_action->port->handle;
1796 req->erp_action = erp_action;
1797 req->handler = zfcp_fsf_close_physical_port_handler;
1798 erp_action->fsf_req = req;
c41f8cbd 1799
287ac01a 1800 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1801 retval = zfcp_fsf_req_send(req);
1da177e4 1802 if (retval) {
c41f8cbd 1803 zfcp_fsf_req_free(req);
1da177e4 1804 erp_action->fsf_req = NULL;
1da177e4 1805 }
c41f8cbd 1806out:
0406289e 1807 spin_unlock_bh(&adapter->req_q_lock);
1da177e4
LT		 1808 return retval;
1809}
1810
c41f8cbd 1811static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
1da177e4 1812{
c41f8cbd
SS		 1813 struct zfcp_adapter *adapter = req->adapter;
1814 struct zfcp_unit *unit = req->data;
1815 struct fsf_qtcb_header *header = &req->qtcb->header;
1816 struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
1817 struct fsf_queue_designator *queue_designator =
1818 &header->fsf_status_qual.fsf_queue_designator;
aef4a983 1819 int exclusive, readwrite;
1da177e4 1820
c41f8cbd 1821 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
44cc76f2 1822 return;
1da177e4 1823
1da177e4 1824 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
b64ddf96 1825 ZFCP_STATUS_COMMON_ACCESS_BOXED |
1da177e4
LT		 1826 ZFCP_STATUS_UNIT_SHARED |
1827 ZFCP_STATUS_UNIT_READONLY,
1828 &unit->status);
1829
1da177e4
LT		 1830 switch (header->fsf_status) {
1831
1832 case FSF_PORT_HANDLE_NOT_VALID:
5ffd51a5 1833 zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fsouh_1", req);
c41f8cbd 1834 /* fall through */
1da177e4 1835 case FSF_LUN_ALREADY_OPEN:
1da177e4 1836 break;
1da177e4 1837 case FSF_ACCESS_DENIED:
c41f8cbd 1838 zfcp_fsf_access_denied_unit(req, unit);
1da177e4 1839 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
553448f6 1840 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
1da177e4 1841 break;
1da177e4 1842 case FSF_PORT_BOXED:
5ffd51a5 1843 zfcp_erp_port_boxed(unit->port, "fsouh_2", req);
c41f8cbd
SS		 1844 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1845 ZFCP_STATUS_FSFREQ_RETRY;
1da177e4 1846 break;
1da177e4 1847 case FSF_LUN_SHARING_VIOLATION:
c41f8cbd 1848 if (header->fsf_status_qual.word[0])
553448f6 1849 dev_warn(&adapter->ccw_device->dev,
ff3b24fa
CS		 1850 "LUN 0x%Lx on port 0x%Lx is already in "
1851 "use by CSS%d, MIF Image ID %x\n",
7ba58c9c
SS		 1852 (unsigned long long)unit->fcp_lun,
1853 (unsigned long long)unit->port->wwpn,
ff3b24fa
CS		 1854 queue_designator->cssid,
1855 queue_designator->hla);
c41f8cbd 1856 else
553448f6
CS		 1857 zfcp_act_eval_err(adapter,
1858 header->fsf_status_qual.word[2]);
5ffd51a5 1859 zfcp_erp_unit_access_denied(unit, "fsouh_3", req);
1da177e4
LT		 1860 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
1861 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
c41f8cbd 1862 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1863 break;
1da177e4 1864 case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
c41f8cbd 1865 dev_warn(&adapter->ccw_device->dev,
ff3b24fa
CS		 1866 "No handle is available for LUN "
1867 "0x%016Lx on port 0x%016Lx\n",
7ba58c9c
SS		 1868 (unsigned long long)unit->fcp_lun,
1869 (unsigned long long)unit->port->wwpn);
5ffd51a5 1870 zfcp_erp_unit_failed(unit, "fsouh_4", req);
c41f8cbd
SS		 1871 /* fall through */
1872 case FSF_INVALID_COMMAND_OPTION:
1873 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1874 break;
1da177e4 1875 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 1876 switch (header->fsf_status_qual.word[0]) {
1877 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
65a8d4e1 1878 zfcp_test_link(unit->port);
c41f8cbd 1879 /* fall through */
1da177e4 1880 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
c41f8cbd 1881 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1882 break;
1da177e4
LT		 1883 }
1884 break;
1885
1da177e4 1886 case FSF_GOOD:
1da177e4 1887 unit->handle = header->lun_handle;
1da177e4 1888 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
aef4a983
MS		 1889
1890 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE) &&
1891 (adapter->adapter_features & FSF_FEATURE_LUN_SHARING) &&
6fcf41d1 1892 !zfcp_ccw_priv_sch(adapter)) {
aef4a983
MS		 1893 exclusive = (bottom->lun_access_info &
1894 FSF_UNIT_ACCESS_EXCLUSIVE);
1895 readwrite = (bottom->lun_access_info &
1896 FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);
1897
1da177e4
LT		 1898 if (!exclusive)
1899 atomic_set_mask(ZFCP_STATUS_UNIT_SHARED,
1900 &unit->status);
1901
1902 if (!readwrite) {
1903 atomic_set_mask(ZFCP_STATUS_UNIT_READONLY,
1904 &unit->status);
c41f8cbd 1905 dev_info(&adapter->ccw_device->dev,
ff3b24fa
CS		 1906 "SCSI device at LUN 0x%016Lx on port "
1907 "0x%016Lx opened read-only\n",
7ba58c9c
SS		 1908 (unsigned long long)unit->fcp_lun,
1909 (unsigned long long)unit->port->wwpn);
1da177e4
LT		 1910 }
1911
1912 if (exclusive && !readwrite) {
c41f8cbd 1913 dev_err(&adapter->ccw_device->dev,
ff3b24fa
CS		 1914 "Exclusive read-only access not "
1915 "supported (unit 0x%016Lx, "
1916 "port 0x%016Lx)\n",
7ba58c9c
SS		 1917 (unsigned long long)unit->fcp_lun,
1918 (unsigned long long)unit->port->wwpn);
5ffd51a5 1919 zfcp_erp_unit_failed(unit, "fsouh_5", req);
c41f8cbd 1920 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
5ffd51a5 1921 zfcp_erp_unit_shutdown(unit, 0, "fsouh_6", req);
1da177e4 1922 } else if (!exclusive && readwrite) {
c41f8cbd 1923 dev_err(&adapter->ccw_device->dev,
ff3b24fa
CS		 1924 "Shared read-write access not "
1925 "supported (unit 0x%016Lx, port "
27c3f0a6 1926 "0x%016Lx)\n",
7ba58c9c
SS		 1927 (unsigned long long)unit->fcp_lun,
1928 (unsigned long long)unit->port->wwpn);
5ffd51a5 1929 zfcp_erp_unit_failed(unit, "fsouh_7", req);
c41f8cbd 1930 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
5ffd51a5 1931 zfcp_erp_unit_shutdown(unit, 0, "fsouh_8", req);
1da177e4
LT		 1932 }
1933 }
1da177e4 1934 break;
1da177e4 1935 }
1da177e4
LT		 1936}
1937
c41f8cbd
SS		 1938/**
1939 * zfcp_fsf_open_unit - open unit
1940 * @erp_action: pointer to struct zfcp_erp_action
1941 * Returns: 0 on success, error otherwise
1da177e4 1942 */
c41f8cbd 1943int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
1da177e4 1944{
44cc76f2 1945 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 1946 struct zfcp_adapter *adapter = erp_action->adapter;
1947 struct zfcp_fsf_req *req;
1948 int retval = -EIO;
1949
0406289e 1950 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd 1951 if (zfcp_fsf_req_sbal_get(adapter))
1da177e4 1952 goto out;
1da177e4 1953
c41f8cbd
SS		 1954 req = zfcp_fsf_req_create(adapter, FSF_QTCB_OPEN_LUN,
1955 ZFCP_REQ_AUTO_CLEANUP,
1956 adapter->pool.fsf_req_erp);
025270f0 1957 if (IS_ERR(req)) {
c41f8cbd
SS		 1958 retval = PTR_ERR(req);
1959 goto out;
1960 }
1961
1962 sbale = zfcp_qdio_sbale_req(req);
1da177e4
LT		 1963 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1964 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1965
c41f8cbd
SS		 1966 req->qtcb->header.port_handle = erp_action->port->handle;
1967 req->qtcb->bottom.support.fcp_lun = erp_action->unit->fcp_lun;
1968 req->handler = zfcp_fsf_open_unit_handler;
1969 req->data = erp_action->unit;
1970 req->erp_action = erp_action;
1971 erp_action->fsf_req = req;
1972
1973 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
1974 req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
1975
287ac01a 1976 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1977 retval = zfcp_fsf_req_send(req);
1da177e4 1978 if (retval) {
c41f8cbd 1979 zfcp_fsf_req_free(req);
1da177e4 1980 erp_action->fsf_req = NULL;
1da177e4 1981 }
c41f8cbd 1982out:
0406289e 1983 spin_unlock_bh(&adapter->req_q_lock);
1da177e4
LT		 1984 return retval;
1985}
1986
c41f8cbd 1987static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
1da177e4 1988{
c41f8cbd 1989 struct zfcp_unit *unit = req->data;
1da177e4 1990
c41f8cbd 1991 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
44cc76f2 1992 return;
1da177e4 1993
c41f8cbd 1994 switch (req->qtcb->header.fsf_status) {
1da177e4 1995 case FSF_PORT_HANDLE_NOT_VALID:
5ffd51a5 1996 zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fscuh_1", req);
c41f8cbd 1997 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1998 break;
1da177e4 1999 case FSF_LUN_HANDLE_NOT_VALID:
5ffd51a5 2000 zfcp_erp_port_reopen(unit->port, 0, "fscuh_2", req);
c41f8cbd 2001 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 2002 break;
1da177e4 2003 case FSF_PORT_BOXED:
5ffd51a5 2004 zfcp_erp_port_boxed(unit->port, "fscuh_3", req);
c41f8cbd
SS		 2005 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
2006 ZFCP_STATUS_FSFREQ_RETRY;
1da177e4 2007 break;
1da177e4 2008 case FSF_ADAPTER_STATUS_AVAILABLE:
c41f8cbd 2009 switch (req->qtcb->header.fsf_status_qual.word[0]) {
1da177e4 2010 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
65a8d4e1 2011 zfcp_test_link(unit->port);
c41f8cbd 2012 /* fall through */
1da177e4 2013 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
c41f8cbd 2014 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 2015 break;
2016 }
2017 break;
1da177e4 2018 case FSF_GOOD:
1da177e4 2019 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
1da177e4 2020 break;
1da177e4 2021 }
1da177e4
LT		 2022}
2023
2024/**
c41f8cbd
SS		 2025 * zfcp_fsf_close_unit - close zfcp unit
2026 * @erp_action: pointer to struct zfcp_unit
2027 * Returns: 0 on success, error otherwise
1da177e4 2028 */
c41f8cbd 2029int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
1da177e4 2030{
44cc76f2 2031 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 2032 struct zfcp_adapter *adapter = erp_action->adapter;
2033 struct zfcp_fsf_req *req;
2034 int retval = -EIO;
1da177e4 2035
0406289e 2036 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd 2037 if (zfcp_fsf_req_sbal_get(adapter))
1da177e4 2038 goto out;
c41f8cbd
SS		 2039 req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_LUN,
2040 ZFCP_REQ_AUTO_CLEANUP,
2041 adapter->pool.fsf_req_erp);
025270f0 2042 if (IS_ERR(req)) {
c41f8cbd
SS		 2043 retval = PTR_ERR(req);
2044 goto out;
2045 }
1da177e4 2046
c41f8cbd
SS		 2047 sbale = zfcp_qdio_sbale_req(req);
2048 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1da177e4
LT		 2049 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
2050
c41f8cbd
SS		 2051 req->qtcb->header.port_handle = erp_action->port->handle;
2052 req->qtcb->header.lun_handle = erp_action->unit->handle;
2053 req->handler = zfcp_fsf_close_unit_handler;
2054 req->data = erp_action->unit;
2055 req->erp_action = erp_action;
2056 erp_action->fsf_req = req;
fdf23452 2057
287ac01a 2058 zfcp_fsf_start_erp_timer(req);
c41f8cbd
SS		 2059 retval = zfcp_fsf_req_send(req);
2060 if (retval) {
2061 zfcp_fsf_req_free(req);
2062 erp_action->fsf_req = NULL;
2063 }
2064out:
0406289e 2065 spin_unlock_bh(&adapter->req_q_lock);
c41f8cbd 2066 return retval;
1da177e4
LT		 2067}
2068
c9615858
CS		 2069static void zfcp_fsf_update_lat(struct fsf_latency_record *lat_rec, u32 lat)
2070{
2071 lat_rec->sum += lat;
c41f8cbd
SS		 2072 lat_rec->min = min(lat_rec->min, lat);
2073 lat_rec->max = max(lat_rec->max, lat);
c9615858
CS		 2074}
2075
c41f8cbd 2076static void zfcp_fsf_req_latency(struct zfcp_fsf_req *req)
c9615858
CS		 2077{
2078 struct fsf_qual_latency_info *lat_inf;
2079 struct latency_cont *lat;
c41f8cbd 2080 struct zfcp_unit *unit = req->unit;
c9615858 2081
c41f8cbd 2082 lat_inf = &req->qtcb->prefix.prot_status_qual.latency_info;
c9615858 2083
c41f8cbd 2084 switch (req->qtcb->bottom.io.data_direction) {
c9615858
CS		 2085 case FSF_DATADIR_READ:
2086 lat = &unit->latencies.read;
2087 break;
2088 case FSF_DATADIR_WRITE:
2089 lat = &unit->latencies.write;
2090 break;
2091 case FSF_DATADIR_CMND:
2092 lat = &unit->latencies.cmd;
2093 break;
2094 default:
2095 return;
2096 }
2097
49f0f01c 2098 spin_lock(&unit->latencies.lock);
c9615858
CS		 2099 zfcp_fsf_update_lat(&lat->channel, lat_inf->channel_lat);
2100 zfcp_fsf_update_lat(&lat->fabric, lat_inf->fabric_lat);
2101 lat->counter++;
49f0f01c 2102 spin_unlock(&unit->latencies.lock);
1da177e4
LT		 2103}
2104
0997f1c5
SR		 2105#ifdef CONFIG_BLK_DEV_IO_TRACE
2106static void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
2107{
2108 struct fsf_qual_latency_info *lat_inf;
2109 struct scsi_cmnd *scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
2110 struct request *req = scsi_cmnd->request;
2111 struct zfcp_blk_drv_data trace;
2112 int ticks = fsf_req->adapter->timer_ticks;
2113
2114 trace.flags = 0;
2115 trace.magic = ZFCP_BLK_DRV_DATA_MAGIC;
2116 if (fsf_req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) {
2117 trace.flags |= ZFCP_BLK_LAT_VALID;
2118 lat_inf = &fsf_req->qtcb->prefix.prot_status_qual.latency_info;
2119 trace.channel_lat = lat_inf->channel_lat * ticks;
2120 trace.fabric_lat = lat_inf->fabric_lat * ticks;
2121 }
2122 if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
2123 trace.flags |= ZFCP_BLK_REQ_ERROR;
2124 trace.inb_usage = fsf_req->qdio_inb_usage;
2125 trace.outb_usage = fsf_req->qdio_outb_usage;
2126
2127 blk_add_driver_data(req->q, req, &trace, sizeof(trace));
2128}
2129#else
2130static inline void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
2131{
2132}
2133#endif
2134
c41f8cbd 2135static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
1da177e4 2136{
0ac55aa9 2137 struct scsi_cmnd *scpnt;
1da177e4 2138 struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
c41f8cbd 2139 &(req->qtcb->bottom.io.fcp_rsp);
1da177e4 2140 u32 sns_len;
f76af7d7 2141 char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
1da177e4 2142 unsigned long flags;
1da177e4 2143
c41f8cbd
SS		 2144 read_lock_irqsave(&req->adapter->abort_lock, flags);
2145
0ac55aa9
SS		 2146 scpnt = req->data;
2147 if (unlikely(!scpnt)) {
2148 read_unlock_irqrestore(&req->adapter->abort_lock, flags);
2149 return;
2150 }
2151
c41f8cbd 2152 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ABORTED)) {
feac6a07 2153 set_host_byte(scpnt, DID_SOFT_ERROR);
1da177e4
LT		 2154 goto skip_fsfstatus;
2155 }
2156
c41f8cbd 2157 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
feac6a07 2158 set_host_byte(scpnt, DID_ERROR);
1da177e4
LT		 2159 goto skip_fsfstatus;
2160 }
2161
feac6a07 2162 set_msg_byte(scpnt, COMMAND_COMPLETE);
1da177e4 2163
1da177e4 2164 scpnt->result |= fcp_rsp_iu->scsi_status;
1da177e4 2165
c41f8cbd
SS		 2166 if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)
2167 zfcp_fsf_req_latency(req);
c9615858 2168
0997f1c5
SR		 2169 zfcp_fsf_trace_latency(req);
2170
1da177e4 2171 if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) {
c41f8cbd 2172 if (fcp_rsp_info[3] == RSP_CODE_GOOD)
feac6a07 2173 set_host_byte(scpnt, DID_OK);
c41f8cbd 2174 else {
feac6a07 2175 set_host_byte(scpnt, DID_ERROR);
6f71d9bc 2176 goto skip_fsfstatus;
1da177e4
LT		 2177 }
2178 }
2179
1da177e4 2180 if (unlikely(fcp_rsp_iu->validity.bits.fcp_sns_len_valid)) {
c41f8cbd
SS		 2181 sns_len = FSF_FCP_RSP_SIZE - sizeof(struct fcp_rsp_iu) +
2182 fcp_rsp_iu->fcp_rsp_len;
1da177e4 2183 sns_len = min(sns_len, (u32) SCSI_SENSE_BUFFERSIZE);
1da177e4 2184 sns_len = min(sns_len, fcp_rsp_iu->fcp_sns_len);
1da177e4 2185
9d058ecf 2186 memcpy(scpnt->sense_buffer,
1da177e4 2187 zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu), sns_len);
1da177e4
LT		 2188 }
2189
1da177e4 2190 if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_under)) {
7936a892
FT		 2191 scsi_set_resid(scpnt, fcp_rsp_iu->fcp_resid);
2192 if (scsi_bufflen(scpnt) - scsi_get_resid(scpnt) <
2193 scpnt->underflow)
feac6a07 2194 set_host_byte(scpnt, DID_ERROR);
1da177e4 2195 }
c41f8cbd 2196skip_fsfstatus:
8a36e453 2197 if (scpnt->result != 0)
c41f8cbd 2198 zfcp_scsi_dbf_event_result("erro", 3, req->adapter, scpnt, req);
8a36e453 2199 else if (scpnt->retries > 0)
c41f8cbd 2200 zfcp_scsi_dbf_event_result("retr", 4, req->adapter, scpnt, req);
8a36e453 2201 else
c41f8cbd 2202 zfcp_scsi_dbf_event_result("norm", 6, req->adapter, scpnt, req);
1da177e4 2203
1da177e4 2204 scpnt->host_scribble = NULL;
1da177e4 2205 (scpnt->scsi_done) (scpnt);
1da177e4
LT		 2206 /*
2207 * We must hold this lock until scsi_done has been called.
2208 * Otherwise we may call scsi_done after abort regarding this
2209 * command has completed.
2210 * Note: scsi_done must not block!
2211 */
c41f8cbd 2212 read_unlock_irqrestore(&req->adapter->abort_lock, flags);
1da177e4
LT		 2213}
2214
c41f8cbd 2215static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req)
1da177e4 2216{
1da177e4 2217 struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
c41f8cbd 2218 &(req->qtcb->bottom.io.fcp_rsp);
f76af7d7 2219 char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
1da177e4 2220
c41f8cbd
SS		 2221 if ((fcp_rsp_info[3] != RSP_CODE_GOOD) ||
2222 (req->status & ZFCP_STATUS_FSFREQ_ERROR))
2223 req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
2224}
2225
2226
2227static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
2228{
2229 struct zfcp_unit *unit;
2230 struct fsf_qtcb_header *header = &req->qtcb->header;
2231
2232 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT))
2233 unit = req->data;
2234 else
2235 unit = req->unit;
2236
2237 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
1da177e4 2238 goto skip_fsfstatus;
1da177e4 2239
c41f8cbd
SS		 2240 switch (header->fsf_status) {
2241 case FSF_HANDLE_MISMATCH:
2242 case FSF_PORT_HANDLE_NOT_VALID:
5ffd51a5 2243 zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fssfch1", req);
c41f8cbd
SS		 2244 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2245 break;
2246 case FSF_FCPLUN_NOT_VALID:
2247 case FSF_LUN_HANDLE_NOT_VALID:
5ffd51a5 2248 zfcp_erp_port_reopen(unit->port, 0, "fssfch2", req);
c41f8cbd 2249 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 2250 break;
c41f8cbd
SS		 2251 case FSF_SERVICE_CLASS_NOT_SUPPORTED:
2252 zfcp_fsf_class_not_supp(req);
1da177e4 2253 break;
c41f8cbd
SS		 2254 case FSF_ACCESS_DENIED:
2255 zfcp_fsf_access_denied_unit(req, unit);
2256 break;
2257 case FSF_DIRECTION_INDICATOR_NOT_VALID:
2258 dev_err(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 2259 "Incorrect direction %d, unit 0x%016Lx on port "
2260 "0x%016Lx closed\n",
c41f8cbd 2261 req->qtcb->bottom.io.data_direction,
7ba58c9c
SS		 2262 (unsigned long long)unit->fcp_lun,
2263 (unsigned long long)unit->port->wwpn);
5ffd51a5
SS		 2264 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, "fssfch3",
2265 req);
c41f8cbd
SS		 2266 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2267 break;
2268 case FSF_CMND_LENGTH_NOT_VALID:
2269 dev_err(&req->adapter->ccw_device->dev,
ff3b24fa
CS		 2270 "Incorrect CDB length %d, unit 0x%016Lx on "
2271 "port 0x%016Lx closed\n",
c41f8cbd 2272 req->qtcb->bottom.io.fcp_cmnd_length,
7ba58c9c
SS		 2273 (unsigned long long)unit->fcp_lun,
2274 (unsigned long long)unit->port->wwpn);
5ffd51a5
SS		 2275 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, "fssfch4",
2276 req);
c41f8cbd
SS		 2277 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2278 break;
2279 case FSF_PORT_BOXED:
5ffd51a5 2280 zfcp_erp_port_boxed(unit->port, "fssfch5", req);
c41f8cbd
SS		 2281 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
2282 ZFCP_STATUS_FSFREQ_RETRY;
2283 break;
2284 case FSF_LUN_BOXED:
5ffd51a5 2285 zfcp_erp_unit_boxed(unit, "fssfch6", req);
c41f8cbd
SS		 2286 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
2287 ZFCP_STATUS_FSFREQ_RETRY;
2288 break;
2289 case FSF_ADAPTER_STATUS_AVAILABLE:
2290 if (header->fsf_status_qual.word[0] ==
2291 FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
2292 zfcp_test_link(unit->port);
2293 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 2294 break;
1da177e4 2295 }
c41f8cbd
SS		 2296skip_fsfstatus:
2297 if (req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
2298 zfcp_fsf_send_fcp_ctm_handler(req);
2299 else {
2300 zfcp_fsf_send_fcp_command_task_handler(req);
2301 req->unit = NULL;
2302 zfcp_unit_put(unit);
2303 }
1da177e4
LT		 2304}
2305
7ba58c9c
SS		 2306static void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, u32 fcp_dl)
2307{
2308 u32 *fcp_dl_ptr;
2309
2310 /*
2311 * fcp_dl_addr = start address of fcp_cmnd structure +
2312 * size of fixed part + size of dynamically sized add_dcp_cdb field
2313 * SEE FCP-2 documentation
2314 */
2315 fcp_dl_ptr = (u32 *) ((unsigned char *) &fcp_cmd[1] +
2316 (fcp_cmd->add_fcp_cdb_length << 2));
2317 *fcp_dl_ptr = fcp_dl;
2318}
2319
c41f8cbd
SS		 2320/**
2321 * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
c41f8cbd
SS		 2322 * @unit: unit where command is sent to
2323 * @scsi_cmnd: scsi command to be sent
1da177e4 2324 */
63caf367
CS		 2325int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
2326 struct scsi_cmnd *scsi_cmnd)
1da177e4 2327{
c41f8cbd
SS		 2328 struct zfcp_fsf_req *req;
2329 struct fcp_cmnd_iu *fcp_cmnd_iu;
bc90c863 2330 unsigned int sbtype = SBAL_FLAGS0_TYPE_READ;
c41f8cbd 2331 int real_bytes, retval = -EIO;
63caf367 2332 struct zfcp_adapter *adapter = unit->port->adapter;
1da177e4 2333
c41f8cbd
SS		 2334 if (unlikely(!(atomic_read(&unit->status) &
2335 ZFCP_STATUS_COMMON_UNBLOCKED)))
2336 return -EBUSY;
1da177e4 2337
0406289e 2338 spin_lock(&adapter->req_q_lock);
8fdf30d5
CS		 2339 if (atomic_read(&adapter->req_q.count) <= 0) {
2340 atomic_inc(&adapter->qdio_outb_full);
c41f8cbd 2341 goto out;
8fdf30d5 2342 }
63caf367
CS		 2343 req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND,
2344 ZFCP_REQ_AUTO_CLEANUP,
c41f8cbd 2345 adapter->pool.fsf_req_scsi);
025270f0 2346 if (IS_ERR(req)) {
c41f8cbd
SS		 2347 retval = PTR_ERR(req);
2348 goto out;
2349 }
2350
2351 zfcp_unit_get(unit);
2352 req->unit = unit;
2353 req->data = scsi_cmnd;
2354 req->handler = zfcp_fsf_send_fcp_command_handler;
2355 req->qtcb->header.lun_handle = unit->handle;
2356 req->qtcb->header.port_handle = unit->port->handle;
2357 req->qtcb->bottom.io.service_class = FSF_CLASS_3;
2358
2359 scsi_cmnd->host_scribble = (unsigned char *) req->req_id;
2360
2361 fcp_cmnd_iu = (struct fcp_cmnd_iu *) &(req->qtcb->bottom.io.fcp_cmnd);
2362 fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
2363 /*
2364 * set depending on data direction:
2365 * data direction bits in SBALE (SB Type)
2366 * data direction bits in QTCB
2367 * data direction bits in FCP_CMND IU
2368 */
2369 switch (scsi_cmnd->sc_data_direction) {
2370 case DMA_NONE:
2371 req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
1da177e4 2372 break;
c41f8cbd
SS		 2373 case DMA_FROM_DEVICE:
2374 req->qtcb->bottom.io.data_direction = FSF_DATADIR_READ;
c41f8cbd
SS		 2375 fcp_cmnd_iu->rddata = 1;
2376 break;
2377 case DMA_TO_DEVICE:
2378 req->qtcb->bottom.io.data_direction = FSF_DATADIR_WRITE;
2379 sbtype = SBAL_FLAGS0_TYPE_WRITE;
2380 fcp_cmnd_iu->wddata = 1;
1da177e4 2381 break;
c41f8cbd 2382 case DMA_BIDIRECTIONAL:
c41f8cbd 2383 goto failed_scsi_cmnd;
1da177e4
LT		 2384 }
2385
c41f8cbd
SS		 2386 if (likely((scsi_cmnd->device->simple_tags) ||
2387 ((atomic_read(&unit->status) & ZFCP_STATUS_UNIT_READONLY) &&
2388 (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_SHARED))))
2389 fcp_cmnd_iu->task_attribute = SIMPLE_Q;
2390 else
2391 fcp_cmnd_iu->task_attribute = UNTAGGED;
1da177e4 2392
c41f8cbd
SS		 2393 if (unlikely(scsi_cmnd->cmd_len > FCP_CDB_LENGTH))
2394 fcp_cmnd_iu->add_fcp_cdb_length =
2395 (scsi_cmnd->cmd_len - FCP_CDB_LENGTH) >> 2;
1da177e4 2396
c41f8cbd 2397 memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
45633fdc 2398
c41f8cbd 2399 req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
7ba58c9c 2400 fcp_cmnd_iu->add_fcp_cdb_length + sizeof(u32);
1da177e4 2401
c41f8cbd
SS		 2402 real_bytes = zfcp_qdio_sbals_from_sg(req, sbtype,
2403 scsi_sglist(scsi_cmnd),
2404 FSF_MAX_SBALS_PER_REQ);
2405 if (unlikely(real_bytes < 0)) {
bc90c863 2406 if (req->sbal_number >= FSF_MAX_SBALS_PER_REQ) {
c41f8cbd 2407 dev_err(&adapter->ccw_device->dev,
ff3b24fa
CS		 2408 "Oversize data package, unit 0x%016Lx "
2409 "on port 0x%016Lx closed\n",
7ba58c9c
SS		 2410 (unsigned long long)unit->fcp_lun,
2411 (unsigned long long)unit->port->wwpn);
5ffd51a5 2412 zfcp_erp_unit_shutdown(unit, 0, "fssfct1", req);
c41f8cbd
SS		 2413 retval = -EINVAL;
2414 }
2415 goto failed_scsi_cmnd;
1da177e4 2416 }
1da177e4 2417
c41f8cbd 2418 zfcp_set_fcp_dl(fcp_cmnd_iu, real_bytes);
1da177e4 2419
c41f8cbd
SS		 2420 retval = zfcp_fsf_req_send(req);
2421 if (unlikely(retval))
2422 goto failed_scsi_cmnd;
1da177e4 2423
c41f8cbd 2424 goto out;
1da177e4 2425
c41f8cbd
SS		 2426failed_scsi_cmnd:
2427 zfcp_unit_put(unit);
2428 zfcp_fsf_req_free(req);
2429 scsi_cmnd->host_scribble = NULL;
2430out:
0406289e 2431 spin_unlock(&adapter->req_q_lock);
c41f8cbd 2432 return retval;
1da177e4
LT		 2433}
2434
2435/**
c41f8cbd 2436 * zfcp_fsf_send_fcp_ctm - send SCSI task management command
c41f8cbd
SS		 2437 * @unit: pointer to struct zfcp_unit
2438 * @tm_flags: unsigned byte for task management flags
c41f8cbd 2439 * Returns: on success pointer to struct fsf_req, NULL otherwise
1da177e4 2440 */
63caf367 2441struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
1da177e4 2442{
44cc76f2 2443 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 2444 struct zfcp_fsf_req *req = NULL;
2445 struct fcp_cmnd_iu *fcp_cmnd_iu;
63caf367 2446 struct zfcp_adapter *adapter = unit->port->adapter;
1da177e4 2447
c41f8cbd
SS		 2448 if (unlikely(!(atomic_read(&unit->status) &
2449 ZFCP_STATUS_COMMON_UNBLOCKED)))
2450 return NULL;
1da177e4 2451
92cab0d9
CS		 2452 spin_lock_bh(&adapter->req_q_lock);
2453 if (zfcp_fsf_req_sbal_get(adapter))
c41f8cbd 2454 goto out;
63caf367 2455 req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, 0,
c41f8cbd 2456 adapter->pool.fsf_req_scsi);
633528c3
SS		 2457 if (IS_ERR(req)) {
2458 req = NULL;
c41f8cbd 2459 goto out;
633528c3 2460 }
1da177e4 2461
c41f8cbd
SS		 2462 req->status |= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT;
2463 req->data = unit;
2464 req->handler = zfcp_fsf_send_fcp_command_handler;
2465 req->qtcb->header.lun_handle = unit->handle;
2466 req->qtcb->header.port_handle = unit->port->handle;
2467 req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
2468 req->qtcb->bottom.io.service_class = FSF_CLASS_3;
2469 req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
7ba58c9c 2470 sizeof(u32);
c41f8cbd
SS		 2471
2472 sbale = zfcp_qdio_sbale_req(req);
2473 sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
2474 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1da177e4 2475
c41f8cbd
SS		 2476 fcp_cmnd_iu = (struct fcp_cmnd_iu *) &req->qtcb->bottom.io.fcp_cmnd;
2477 fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
2478 fcp_cmnd_iu->task_management_flags = tm_flags;
1da177e4 2479
c41f8cbd
SS		 2480 zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
2481 if (!zfcp_fsf_req_send(req))
2482 goto out;
1da177e4 2483
c41f8cbd
SS		 2484 zfcp_fsf_req_free(req);
2485 req = NULL;
2486out:
92cab0d9 2487 spin_unlock_bh(&adapter->req_q_lock);
c41f8cbd
SS		 2488 return req;
2489}
1da177e4 2490
c41f8cbd
SS		 2491static void zfcp_fsf_control_file_handler(struct zfcp_fsf_req *req)
2492{
1da177e4
LT		 2493}
2494
c41f8cbd
SS		 2495/**
2496 * zfcp_fsf_control_file - control file upload/download
2497 * @adapter: pointer to struct zfcp_adapter
2498 * @fsf_cfdc: pointer to struct zfcp_fsf_cfdc
2499 * Returns: on success pointer to struct zfcp_fsf_req, NULL otherwise
1da177e4 2500 */
c41f8cbd
SS		 2501struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
2502 struct zfcp_fsf_cfdc *fsf_cfdc)
1da177e4 2503{
44cc76f2 2504 struct qdio_buffer_element *sbale;
c41f8cbd
SS		 2505 struct zfcp_fsf_req *req = NULL;
2506 struct fsf_qtcb_bottom_support *bottom;
2507 int direction, retval = -EIO, bytes;
2508
2509 if (!(adapter->adapter_features & FSF_FEATURE_CFDC))
2510 return ERR_PTR(-EOPNOTSUPP);
2511
2512 switch (fsf_cfdc->command) {
2513 case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
2514 direction = SBAL_FLAGS0_TYPE_WRITE;
2515 break;
2516 case FSF_QTCB_UPLOAD_CONTROL_FILE:
2517 direction = SBAL_FLAGS0_TYPE_READ;
2518 break;
2519 default:
2520 return ERR_PTR(-EINVAL);
2521 }
1da177e4 2522
0406289e 2523 spin_lock_bh(&adapter->req_q_lock);
c41f8cbd
SS		 2524 if (zfcp_fsf_req_sbal_get(adapter))
2525 goto out;
1da177e4 2526
c41f8cbd 2527 req = zfcp_fsf_req_create(adapter, fsf_cfdc->command, 0, NULL);
025270f0 2528 if (IS_ERR(req)) {
c41f8cbd
SS		 2529 retval = -EPERM;
2530 goto out;
2531 }
1da177e4 2532
c41f8cbd 2533 req->handler = zfcp_fsf_control_file_handler;
1da177e4 2534
c41f8cbd
SS		 2535 sbale = zfcp_qdio_sbale_req(req);
2536 sbale[0].flags |= direction;
8a36e453 2537
c41f8cbd
SS		 2538 bottom = &req->qtcb->bottom.support;
2539 bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
2540 bottom->option = fsf_cfdc->option;
8a36e453 2541
c41f8cbd
SS		 2542 bytes = zfcp_qdio_sbals_from_sg(req, direction, fsf_cfdc->sg,
2543 FSF_MAX_SBALS_PER_REQ);
2544 if (bytes != ZFCP_CFDC_MAX_SIZE) {
2545 retval = -ENOMEM;
2546 zfcp_fsf_req_free(req);
2547 goto out;
2548 }
1da177e4 2549
c41f8cbd
SS		 2550 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2551 retval = zfcp_fsf_req_send(req);
2552out:
0406289e 2553 spin_unlock_bh(&adapter->req_q_lock);
8a36e453 2554
c41f8cbd
SS		 2555 if (!retval) {
2556 wait_event(req->completion_wq,
2557 req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
2558 return req;
1da177e4 2559 }
c41f8cbd 2560 return ERR_PTR(retval);
1da177e4 2561}
kernel source for telekom puls (alcatel/mediatek)