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