projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
zfcp: restore tracing of handle for port and LUN with HBA records
[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;
c41f8cbd
SS		 1088 req->data = ct;
1089
2c55b750 1090 zfcp_dbf_san_req("fssct_1", req, wka_port->d_id);
1da177e4 1091
c41f8cbd
SS		 1092 ret = zfcp_fsf_req_send(req);
1093 if (ret)
1094 goto failed_send;
1da177e4 1095
c41f8cbd 1096 goto out;
1da177e4 1097
c41f8cbd
SS		 1098failed_send:
1099 zfcp_fsf_req_free(req);
c41f8cbd 1100out:
44a24cb3 1101 spin_unlock_irq(&qdio->req_q_lock);
c41f8cbd 1102 return ret;
1da177e4
LT		 1103}
1104
c41f8cbd 1105static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
1da177e4 1106{
7c7dc196 1107 struct zfcp_fsf_ct_els *send_els = req->data;
c41f8cbd
SS		 1108 struct zfcp_port *port = send_els->port;
1109 struct fsf_qtcb_header *header = &req->qtcb->header;
1da177e4 1110
c41f8cbd 1111 send_els->status = -EINVAL;
1da177e4 1112
c41f8cbd 1113 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1da177e4
LT		 1114 goto skip_fsfstatus;
1115
1116 switch (header->fsf_status) {
1da177e4 1117 case FSF_GOOD:
2c55b750 1118 zfcp_dbf_san_res("fsselh1", req);
c41f8cbd 1119 send_els->status = 0;
1da177e4 1120 break;
1da177e4 1121 case FSF_SERVICE_CLASS_NOT_SUPPORTED:
c41f8cbd 1122 zfcp_fsf_class_not_supp(req);
1da177e4 1123 break;
1da177e4 1124 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 1125 switch (header->fsf_status_qual.word[0]){
1126 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1da177e4 1127 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1da177e4 1128 case FSF_SQ_RETRY_IF_POSSIBLE:
c41f8cbd 1129 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1130 break;
1da177e4
LT		 1131 }
1132 break;
1da177e4 1133 case FSF_ELS_COMMAND_REJECTED:
1da177e4 1134 case FSF_PAYLOAD_SIZE_MISMATCH:
1da177e4 1135 case FSF_REQUEST_SIZE_TOO_LARGE:
1da177e4 1136 case FSF_RESPONSE_SIZE_TOO_LARGE:
1da177e4 1137 break;
1da177e4 1138 case FSF_ACCESS_DENIED:
a1ca4831
CS		 1139 if (port) {
1140 zfcp_cfdc_port_denied(port, &header->fsf_status_qual);
1141 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1142 }
1da177e4 1143 break;
c41f8cbd 1144 case FSF_SBAL_MISMATCH:
25985edc 1145 /* should never occur, avoided in zfcp_fsf_send_els */
c41f8cbd 1146 /* fall through */
1da177e4 1147 default:
c41f8cbd 1148 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 1149 break;
1150 }
1da177e4 1151skip_fsfstatus:
aa551daf 1152 if (send_els->handler)
1da177e4 1153 send_els->handler(send_els->handler_data);
c41f8cbd 1154}
1da177e4 1155
c41f8cbd
SS		 1156/**
1157 * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
1158 * @els: pointer to struct zfcp_send_els with data for the command
1159 */
7c7dc196 1160int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
51375ee8 1161 struct zfcp_fsf_ct_els *els, unsigned int timeout)
c41f8cbd
SS		 1162{
1163 struct zfcp_fsf_req *req;
7c7dc196 1164 struct zfcp_qdio *qdio = adapter->qdio;
c41f8cbd
SS		 1165 int ret = -EIO;
1166
44a24cb3 1167 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1168 if (zfcp_qdio_sbal_get(qdio))
c41f8cbd 1169 goto out;
09a46c6e 1170
1674b405 1171 req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_ELS,
3ec90878 1172 SBAL_SFLAGS0_TYPE_WRITE_READ, NULL);
09a46c6e 1173
025270f0 1174 if (IS_ERR(req)) {
c41f8cbd
SS		 1175 ret = PTR_ERR(req);
1176 goto out;
1177 }
1178
09a46c6e 1179 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
01b04759 1180
86a9668a
SS		 1181 if (!zfcp_adapter_multi_buffer_active(adapter))
1182 zfcp_qdio_sbal_limit(qdio, &req->qdio_req, 2);
01b04759
SS		 1183
1184 ret = zfcp_fsf_setup_ct_els(req, els->req, els->resp, timeout);
44cc76f2 1185
c41f8cbd
SS		 1186 if (ret)
1187 goto failed_send;
1188
7c7dc196 1189 hton24(req->qtcb->bottom.support.d_id, d_id);
c41f8cbd 1190 req->handler = zfcp_fsf_send_els_handler;
c41f8cbd
SS		 1191 req->data = els;
1192
2c55b750 1193 zfcp_dbf_san_req("fssels1", req, d_id);
c41f8cbd 1194
c41f8cbd
SS		 1195 ret = zfcp_fsf_req_send(req);
1196 if (ret)
1197 goto failed_send;
1198
1199 goto out;
1200
1201failed_send:
1202 zfcp_fsf_req_free(req);
1203out:
44a24cb3 1204 spin_unlock_irq(&qdio->req_q_lock);
c41f8cbd 1205 return ret;
1da177e4
LT		 1206}
1207
c41f8cbd 1208int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
1da177e4 1209{
c41f8cbd 1210 struct zfcp_fsf_req *req;
564e1c86 1211 struct zfcp_qdio *qdio = erp_action->adapter->qdio;
c41f8cbd
SS		 1212 int retval = -EIO;
1213
44a24cb3 1214 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1215 if (zfcp_qdio_sbal_get(qdio))
c41f8cbd 1216 goto out;
09a46c6e 1217
564e1c86 1218 req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA,
3ec90878 1219 SBAL_SFLAGS0_TYPE_READ,
564e1c86 1220 qdio->adapter->pool.erp_req);
09a46c6e 1221
025270f0 1222 if (IS_ERR(req)) {
c41f8cbd
SS		 1223 retval = PTR_ERR(req);
1224 goto out;
1da177e4
LT		 1225 }
1226
09a46c6e 1227 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1228 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1da177e4 1229
c41f8cbd 1230 req->qtcb->bottom.config.feature_selection =
aef4a983
MS		 1231 FSF_FEATURE_CFDC |
1232 FSF_FEATURE_LUN_SHARING |
9eb69aff 1233 FSF_FEATURE_NOTIFICATION_LOST |
aef4a983 1234 FSF_FEATURE_UPDATE_ALERT;
c41f8cbd
SS		 1235 req->erp_action = erp_action;
1236 req->handler = zfcp_fsf_exchange_config_data_handler;
e60a6d69 1237 erp_action->fsf_req_id = req->req_id;
1da177e4 1238
287ac01a 1239 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1240 retval = zfcp_fsf_req_send(req);
1da177e4 1241 if (retval) {
c41f8cbd 1242 zfcp_fsf_req_free(req);
e60a6d69 1243 erp_action->fsf_req_id = 0;
1da177e4 1244 }
c41f8cbd 1245out:
44a24cb3 1246 spin_unlock_irq(&qdio->req_q_lock);
52ef11a7
SS		 1247 return retval;
1248}
1da177e4 1249
564e1c86 1250int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio,
c41f8cbd 1251 struct fsf_qtcb_bottom_config *data)
52ef11a7 1252{
c41f8cbd
SS		 1253 struct zfcp_fsf_req *req = NULL;
1254 int retval = -EIO;
1255
44a24cb3 1256 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1257 if (zfcp_qdio_sbal_get(qdio))
ada81b74 1258 goto out_unlock;
c41f8cbd 1259
1674b405 1260 req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA,
3ec90878 1261 SBAL_SFLAGS0_TYPE_READ, NULL);
09a46c6e 1262
025270f0 1263 if (IS_ERR(req)) {
c41f8cbd 1264 retval = PTR_ERR(req);
ada81b74 1265 goto out_unlock;
52ef11a7
SS		 1266 }
1267
1674b405 1268 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
c41f8cbd 1269 req->handler = zfcp_fsf_exchange_config_data_handler;
52ef11a7 1270
c41f8cbd 1271 req->qtcb->bottom.config.feature_selection =
52ef11a7
SS		 1272 FSF_FEATURE_CFDC |
1273 FSF_FEATURE_LUN_SHARING |
1274 FSF_FEATURE_NOTIFICATION_LOST |
1275 FSF_FEATURE_UPDATE_ALERT;
1276
1277 if (data)
c41f8cbd 1278 req->data = data;
52ef11a7 1279
c41f8cbd
SS		 1280 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1281 retval = zfcp_fsf_req_send(req);
44a24cb3 1282 spin_unlock_irq(&qdio->req_q_lock);
553448f6 1283 if (!retval)
058b8647 1284 wait_for_completion(&req->completion);
52ef11a7 1285
c41f8cbd 1286 zfcp_fsf_req_free(req);
ada81b74 1287 return retval;
52ef11a7 1288
ada81b74 1289out_unlock:
44a24cb3 1290 spin_unlock_irq(&qdio->req_q_lock);
1da177e4
LT		 1291 return retval;
1292}
1293
1da177e4
LT		 1294/**
1295 * zfcp_fsf_exchange_port_data - request information about local port
aef4a983 1296 * @erp_action: ERP action for the adapter for which port data is requested
c41f8cbd 1297 * Returns: 0 on success, error otherwise
1da177e4 1298 */
c41f8cbd 1299int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
1da177e4 1300{
564e1c86 1301 struct zfcp_qdio *qdio = erp_action->adapter->qdio;
c41f8cbd 1302 struct zfcp_fsf_req *req;
c41f8cbd 1303 int retval = -EIO;
1da177e4 1304
564e1c86 1305 if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
52ef11a7 1306 return -EOPNOTSUPP;
1da177e4 1307
44a24cb3 1308 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1309 if (zfcp_qdio_sbal_get(qdio))
c41f8cbd 1310 goto out;
09a46c6e 1311
564e1c86 1312 req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA,
3ec90878 1313 SBAL_SFLAGS0_TYPE_READ,
564e1c86 1314 qdio->adapter->pool.erp_req);
09a46c6e 1315
025270f0 1316 if (IS_ERR(req)) {
c41f8cbd
SS		 1317 retval = PTR_ERR(req);
1318 goto out;
aef4a983
MS		 1319 }
1320
09a46c6e 1321 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1322 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1da177e4 1323
c41f8cbd
SS		 1324 req->handler = zfcp_fsf_exchange_port_data_handler;
1325 req->erp_action = erp_action;
e60a6d69 1326 erp_action->fsf_req_id = req->req_id;
52ef11a7 1327
287ac01a 1328 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1329 retval = zfcp_fsf_req_send(req);
1da177e4 1330 if (retval) {
c41f8cbd 1331 zfcp_fsf_req_free(req);
e60a6d69 1332 erp_action->fsf_req_id = 0;
52ef11a7 1333 }
c41f8cbd 1334out:
44a24cb3 1335 spin_unlock_irq(&qdio->req_q_lock);
52ef11a7
SS		 1336 return retval;
1337}
1338
52ef11a7
SS		 1339/**
1340 * zfcp_fsf_exchange_port_data_sync - request information about local port
564e1c86 1341 * @qdio: pointer to struct zfcp_qdio
c41f8cbd
SS		 1342 * @data: pointer to struct fsf_qtcb_bottom_port
1343 * Returns: 0 on success, error otherwise
52ef11a7 1344 */
564e1c86 1345int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio,
c41f8cbd 1346 struct fsf_qtcb_bottom_port *data)
52ef11a7 1347{
c41f8cbd
SS		 1348 struct zfcp_fsf_req *req = NULL;
1349 int retval = -EIO;
52ef11a7 1350
564e1c86 1351 if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
52ef11a7 1352 return -EOPNOTSUPP;
52ef11a7 1353
44a24cb3 1354 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1355 if (zfcp_qdio_sbal_get(qdio))
ada81b74 1356 goto out_unlock;
c41f8cbd 1357
1674b405 1358 req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA,
3ec90878 1359 SBAL_SFLAGS0_TYPE_READ, NULL);
09a46c6e 1360
025270f0 1361 if (IS_ERR(req)) {
c41f8cbd 1362 retval = PTR_ERR(req);
ada81b74 1363 goto out_unlock;
1da177e4
LT		 1364 }
1365
52ef11a7 1366 if (data)
c41f8cbd 1367 req->data = data;
52ef11a7 1368
1674b405 1369 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
52ef11a7 1370
c41f8cbd
SS		 1371 req->handler = zfcp_fsf_exchange_port_data_handler;
1372 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1373 retval = zfcp_fsf_req_send(req);
44a24cb3 1374 spin_unlock_irq(&qdio->req_q_lock);
ada81b74 1375
553448f6 1376 if (!retval)
058b8647
SS		 1377 wait_for_completion(&req->completion);
1378
c41f8cbd 1379 zfcp_fsf_req_free(req);
1da177e4 1380
1da177e4 1381 return retval;
ada81b74
CS		 1382
1383out_unlock:
44a24cb3 1384 spin_unlock_irq(&qdio->req_q_lock);
ada81b74 1385 return retval;
1da177e4
LT		 1386}
1387
c41f8cbd 1388static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
1da177e4 1389{
c41f8cbd
SS		 1390 struct zfcp_port *port = req->data;
1391 struct fsf_qtcb_header *header = &req->qtcb->header;
9d05ce2c 1392 struct fc_els_flogi *plogi;
1da177e4 1393
c41f8cbd 1394 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
a17c5855 1395 goto out;
1da177e4 1396
1da177e4 1397 switch (header->fsf_status) {
1da177e4 1398 case FSF_PORT_ALREADY_OPEN:
1da177e4 1399 break;
1da177e4 1400 case FSF_ACCESS_DENIED:
a1ca4831
CS		 1401 zfcp_cfdc_port_denied(port, &header->fsf_status_qual);
1402 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1403 break;
1da177e4 1404 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
c41f8cbd 1405 dev_warn(&req->adapter->ccw_device->dev,
ff3b24fa 1406 "Not enough FCP adapter resources to open "
7ba58c9c
SS		 1407 "remote port 0x%016Lx\n",
1408 (unsigned long long)port->wwpn);
edaed859
SS		 1409 zfcp_erp_set_port_status(port,
1410 ZFCP_STATUS_COMMON_ERP_FAILED);
c41f8cbd 1411 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1412 break;
1da177e4 1413 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 1414 switch (header->fsf_status_qual.word[0]) {
1415 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1da177e4 1416 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1da177e4 1417 case FSF_SQ_NO_RETRY_POSSIBLE:
c41f8cbd 1418 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 1419 break;
1420 }
1421 break;
1da177e4 1422 case FSF_GOOD:
1da177e4 1423 port->handle = header->port_handle;
1da177e4
LT		 1424 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN |
1425 ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
d736a27b
AH		 1426 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1427 ZFCP_STATUS_COMMON_ACCESS_BOXED,
1428 &port->status);
1da177e4
LT		 1429 /* check whether D_ID has changed during open */
1430 /*
1431 * FIXME: This check is not airtight, as the FCP channel does
1432 * not monitor closures of target port connections caused on
1433 * the remote side. Thus, they might miss out on invalidating
1434 * locally cached WWPNs (and other N_Port parameters) of gone
1435 * target ports. So, our heroic attempt to make things safe
1436 * could be undermined by 'open port' response data tagged with
1437 * obsolete WWPNs. Another reason to monitor potential
1438 * connection closures ourself at least (by interpreting
1439 * incoming ELS' and unsolicited status). It just crosses my
1440 * mind that one should be able to cross-check by means of
1441 * another GID_PN straight after a port has been opened.
1442 * Alternately, an ADISC/PDISC ELS should suffice, as well.
1443 */
9d05ce2c 1444 plogi = (struct fc_els_flogi *) req->qtcb->bottom.support.els;
39eb7e9a 1445 if (req->qtcb->bottom.support.els1_length >=
9d05ce2c 1446 FSF_PLOGI_MIN_LEN)
c41f8cbd 1447 zfcp_fc_plogi_evaluate(port, plogi);
1da177e4 1448 break;
1da177e4 1449 case FSF_UNKNOWN_OP_SUBTYPE:
c41f8cbd 1450 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 1451 break;
1452 }
a17c5855
MP		 1453
1454out:
615f59e0 1455 put_device(&port->dev);
1da177e4
LT		 1456}
1457
c41f8cbd
SS		 1458/**
1459 * zfcp_fsf_open_port - create and send open port request
1460 * @erp_action: pointer to struct zfcp_erp_action
1461 * Returns: 0 on success, error otherwise
1da177e4 1462 */
c41f8cbd 1463int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
1da177e4 1464{
564e1c86 1465 struct zfcp_qdio *qdio = erp_action->adapter->qdio;
a17c5855 1466 struct zfcp_port *port = erp_action->port;
564e1c86 1467 struct zfcp_fsf_req *req;
c41f8cbd
SS		 1468 int retval = -EIO;
1469
44a24cb3 1470 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1471 if (zfcp_qdio_sbal_get(qdio))
c41f8cbd
SS		 1472 goto out;
1473
564e1c86 1474 req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID,
3ec90878 1475 SBAL_SFLAGS0_TYPE_READ,
564e1c86 1476 qdio->adapter->pool.erp_req);
09a46c6e 1477
025270f0 1478 if (IS_ERR(req)) {
c41f8cbd 1479 retval = PTR_ERR(req);
1da177e4 1480 goto out;
c41f8cbd 1481 }
1da177e4 1482
09a46c6e 1483 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1484 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1da177e4 1485
c41f8cbd 1486 req->handler = zfcp_fsf_open_port_handler;
800c0cad 1487 hton24(req->qtcb->bottom.support.d_id, port->d_id);
a17c5855 1488 req->data = port;
c41f8cbd 1489 req->erp_action = erp_action;
e60a6d69 1490 erp_action->fsf_req_id = req->req_id;
615f59e0 1491 get_device(&port->dev);
c41f8cbd 1492
287ac01a 1493 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1494 retval = zfcp_fsf_req_send(req);
1da177e4 1495 if (retval) {
c41f8cbd 1496 zfcp_fsf_req_free(req);
e60a6d69 1497 erp_action->fsf_req_id = 0;
615f59e0 1498 put_device(&port->dev);
1da177e4 1499 }
c41f8cbd 1500out:
44a24cb3 1501 spin_unlock_irq(&qdio->req_q_lock);
1da177e4
LT		 1502 return retval;
1503}
1504
c41f8cbd 1505static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
1da177e4 1506{
c41f8cbd 1507 struct zfcp_port *port = req->data;
1da177e4 1508
c41f8cbd 1509 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
44cc76f2 1510 return;
1da177e4 1511
c41f8cbd 1512 switch (req->qtcb->header.fsf_status) {
1da177e4 1513 case FSF_PORT_HANDLE_NOT_VALID:
ea4a3a6a 1514 zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1");
c41f8cbd 1515 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1516 break;
1da177e4 1517 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4 1518 break;
1da177e4 1519 case FSF_GOOD:
edaed859 1520 zfcp_erp_clear_port_status(port, ZFCP_STATUS_COMMON_OPEN);
1da177e4 1521 break;
1da177e4 1522 }
1da177e4
LT		 1523}
1524
c41f8cbd
SS		 1525/**
1526 * zfcp_fsf_close_port - create and send close port request
1527 * @erp_action: pointer to struct zfcp_erp_action
1528 * Returns: 0 on success, error otherwise
1da177e4 1529 */
c41f8cbd 1530int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
1da177e4 1531{
564e1c86 1532 struct zfcp_qdio *qdio = erp_action->adapter->qdio;
c41f8cbd
SS		 1533 struct zfcp_fsf_req *req;
1534 int retval = -EIO;
1535
44a24cb3 1536 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1537 if (zfcp_qdio_sbal_get(qdio))
c41f8cbd
SS		 1538 goto out;
1539
564e1c86 1540 req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT,
3ec90878 1541 SBAL_SFLAGS0_TYPE_READ,
564e1c86 1542 qdio->adapter->pool.erp_req);
09a46c6e 1543
025270f0 1544 if (IS_ERR(req)) {
c41f8cbd 1545 retval = PTR_ERR(req);
1da177e4 1546 goto out;
c41f8cbd 1547 }
1da177e4 1548
09a46c6e 1549 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1550 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1da177e4 1551
c41f8cbd
SS		 1552 req->handler = zfcp_fsf_close_port_handler;
1553 req->data = erp_action->port;
1554 req->erp_action = erp_action;
1555 req->qtcb->header.port_handle = erp_action->port->handle;
e60a6d69 1556 erp_action->fsf_req_id = req->req_id;
c41f8cbd 1557
287ac01a 1558 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1559 retval = zfcp_fsf_req_send(req);
1da177e4 1560 if (retval) {
c41f8cbd 1561 zfcp_fsf_req_free(req);
e60a6d69 1562 erp_action->fsf_req_id = 0;
1da177e4 1563 }
c41f8cbd 1564out:
44a24cb3 1565 spin_unlock_irq(&qdio->req_q_lock);
1da177e4
LT		 1566 return retval;
1567}
1568
5ab944f9
SS		 1569static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
1570{
bd0072ec 1571 struct zfcp_fc_wka_port *wka_port = req->data;
5ab944f9
SS		 1572 struct fsf_qtcb_header *header = &req->qtcb->header;
1573
1574 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
bd0072ec 1575 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
5ab944f9
SS		 1576 goto out;
1577 }
1578
1579 switch (header->fsf_status) {
1580 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
1581 dev_warn(&req->adapter->ccw_device->dev,
1582 "Opening WKA port 0x%x failed\n", wka_port->d_id);
dceab655 1583 /* fall through */
5ab944f9
SS		 1584 case FSF_ADAPTER_STATUS_AVAILABLE:
1585 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
dceab655 1586 /* fall through */
5ab944f9 1587 case FSF_ACCESS_DENIED:
bd0072ec 1588 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
5ab944f9 1589 break;
5ab944f9
SS		 1590 case FSF_GOOD:
1591 wka_port->handle = header->port_handle;
27f492cc
SS		 1592 /* fall through */
1593 case FSF_PORT_ALREADY_OPEN:
bd0072ec 1594 wka_port->status = ZFCP_FC_WKA_PORT_ONLINE;
5ab944f9
SS		 1595 }
1596out:
1597 wake_up(&wka_port->completion_wq);
1598}
1599
1600/**
1601 * zfcp_fsf_open_wka_port - create and send open wka-port request
bd0072ec 1602 * @wka_port: pointer to struct zfcp_fc_wka_port
5ab944f9
SS		 1603 * Returns: 0 on success, error otherwise
1604 */
bd0072ec 1605int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *wka_port)
5ab944f9 1606{
564e1c86 1607 struct zfcp_qdio *qdio = wka_port->adapter->qdio;
69169095 1608 struct zfcp_fsf_req *req = NULL;
5ab944f9
SS		 1609 int retval = -EIO;
1610
44a24cb3 1611 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1612 if (zfcp_qdio_sbal_get(qdio))
5ab944f9
SS		 1613 goto out;
1614
564e1c86 1615 req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID,
3ec90878 1616 SBAL_SFLAGS0_TYPE_READ,
564e1c86 1617 qdio->adapter->pool.erp_req);
09a46c6e 1618
4e7d7af4 1619 if (IS_ERR(req)) {
5ab944f9
SS		 1620 retval = PTR_ERR(req);
1621 goto out;
1622 }
1623
09a46c6e 1624 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1625 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
5ab944f9
SS		 1626
1627 req->handler = zfcp_fsf_open_wka_port_handler;
800c0cad 1628 hton24(req->qtcb->bottom.support.d_id, wka_port->d_id);
5ab944f9
SS		 1629 req->data = wka_port;
1630
1631 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1632 retval = zfcp_fsf_req_send(req);
1633 if (retval)
1634 zfcp_fsf_req_free(req);
1635out:
44a24cb3 1636 spin_unlock_irq(&qdio->req_q_lock);
69169095
SM		 1637 if (req && !IS_ERR(req))
1638 zfcp_dbf_rec_run_wka("fsowp_1", wka_port, req->req_id);
5ab944f9
SS		 1639 return retval;
1640}
1641
1642static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
1643{
bd0072ec 1644 struct zfcp_fc_wka_port *wka_port = req->data;
5ab944f9
SS		 1645
1646 if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
1647 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
ea4a3a6a 1648 zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1");
5ab944f9
SS		 1649 }
1650
bd0072ec 1651 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
5ab944f9
SS		 1652 wake_up(&wka_port->completion_wq);
1653}
1654
1655/**
1656 * zfcp_fsf_close_wka_port - create and send close wka port request
bd0072ec 1657 * @wka_port: WKA port to open
5ab944f9
SS		 1658 * Returns: 0 on success, error otherwise
1659 */
bd0072ec 1660int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *wka_port)
5ab944f9 1661{
564e1c86 1662 struct zfcp_qdio *qdio = wka_port->adapter->qdio;
69169095 1663 struct zfcp_fsf_req *req = NULL;
5ab944f9
SS		 1664 int retval = -EIO;
1665
44a24cb3 1666 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1667 if (zfcp_qdio_sbal_get(qdio))
5ab944f9
SS		 1668 goto out;
1669
564e1c86 1670 req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT,
3ec90878 1671 SBAL_SFLAGS0_TYPE_READ,
564e1c86 1672 qdio->adapter->pool.erp_req);
09a46c6e 1673
4e7d7af4 1674 if (IS_ERR(req)) {
5ab944f9
SS		 1675 retval = PTR_ERR(req);
1676 goto out;
1677 }
1678
09a46c6e 1679 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1680 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
5ab944f9
SS		 1681
1682 req->handler = zfcp_fsf_close_wka_port_handler;
1683 req->data = wka_port;
1684 req->qtcb->header.port_handle = wka_port->handle;
1685
1686 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1687 retval = zfcp_fsf_req_send(req);
1688 if (retval)
1689 zfcp_fsf_req_free(req);
1690out:
44a24cb3 1691 spin_unlock_irq(&qdio->req_q_lock);
69169095
SM		 1692 if (req && !IS_ERR(req))
1693 zfcp_dbf_rec_run_wka("fscwp_1", wka_port, req->req_id);
5ab944f9
SS		 1694 return retval;
1695}
1696
c41f8cbd 1697static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
1da177e4 1698{
c41f8cbd
SS		 1699 struct zfcp_port *port = req->data;
1700 struct fsf_qtcb_header *header = &req->qtcb->header;
b62a8d9b 1701 struct scsi_device *sdev;
1da177e4 1702
c41f8cbd 1703 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
a5b11dda 1704 return;
1da177e4 1705
1da177e4 1706 switch (header->fsf_status) {
1da177e4 1707 case FSF_PORT_HANDLE_NOT_VALID:
ea4a3a6a 1708 zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1");
c41f8cbd 1709 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1710 break;
1da177e4 1711 case FSF_ACCESS_DENIED:
a1ca4831 1712 zfcp_cfdc_port_denied(port, &header->fsf_status_qual);
1da177e4 1713 break;
1da177e4 1714 case FSF_PORT_BOXED:
5c815d15
CS		 1715 /* can't use generic zfcp_erp_modify_port_status because
1716 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
1717 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
b62a8d9b
CS		 1718 shost_for_each_device(sdev, port->adapter->scsi_host)
1719 if (sdev_to_zfcp(sdev)->port == port)
1720 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1721 &sdev_to_zfcp(sdev)->status);
edaed859
SS		 1722 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ACCESS_BOXED);
1723 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
ea4a3a6a 1724 "fscpph2");
4c571c65 1725 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1726 break;
1da177e4 1727 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 1728 switch (header->fsf_status_qual.word[0]) {
1729 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
c41f8cbd 1730 /* fall through */
1da177e4 1731 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
c41f8cbd 1732 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1733 break;
1da177e4
LT		 1734 }
1735 break;
1da177e4 1736 case FSF_GOOD:
1da177e4
LT		 1737 /* can't use generic zfcp_erp_modify_port_status because
1738 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
1739 */
1740 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
b62a8d9b
CS		 1741 shost_for_each_device(sdev, port->adapter->scsi_host)
1742 if (sdev_to_zfcp(sdev)->port == port)
1743 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1744 &sdev_to_zfcp(sdev)->status);
1da177e4 1745 break;
1da177e4 1746 }
1da177e4
LT		 1747}
1748
c41f8cbd
SS		 1749/**
1750 * zfcp_fsf_close_physical_port - close physical port
1751 * @erp_action: pointer to struct zfcp_erp_action
1752 * Returns: 0 on success
1da177e4 1753 */
c41f8cbd 1754int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
1da177e4 1755{
564e1c86 1756 struct zfcp_qdio *qdio = erp_action->adapter->qdio;
c41f8cbd
SS		 1757 struct zfcp_fsf_req *req;
1758 int retval = -EIO;
1759
44a24cb3 1760 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1761 if (zfcp_qdio_sbal_get(qdio))
1da177e4 1762 goto out;
1da177e4 1763
564e1c86 1764 req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PHYSICAL_PORT,
3ec90878 1765 SBAL_SFLAGS0_TYPE_READ,
564e1c86 1766 qdio->adapter->pool.erp_req);
09a46c6e 1767
025270f0 1768 if (IS_ERR(req)) {
c41f8cbd
SS		 1769 retval = PTR_ERR(req);
1770 goto out;
1771 }
1da177e4 1772
09a46c6e 1773 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1774 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1da177e4 1775
c41f8cbd
SS		 1776 req->data = erp_action->port;
1777 req->qtcb->header.port_handle = erp_action->port->handle;
1778 req->erp_action = erp_action;
1779 req->handler = zfcp_fsf_close_physical_port_handler;
e60a6d69 1780 erp_action->fsf_req_id = req->req_id;
c41f8cbd 1781
287ac01a 1782 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1783 retval = zfcp_fsf_req_send(req);
1da177e4 1784 if (retval) {
c41f8cbd 1785 zfcp_fsf_req_free(req);
e60a6d69 1786 erp_action->fsf_req_id = 0;
1da177e4 1787 }
c41f8cbd 1788out:
44a24cb3 1789 spin_unlock_irq(&qdio->req_q_lock);
1da177e4
LT		 1790 return retval;
1791}
1792
b62a8d9b 1793static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
1da177e4 1794{
c41f8cbd 1795 struct zfcp_adapter *adapter = req->adapter;
b62a8d9b 1796 struct scsi_device *sdev = req->data;
d436de8c 1797 struct zfcp_scsi_dev *zfcp_sdev;
c41f8cbd
SS		 1798 struct fsf_qtcb_header *header = &req->qtcb->header;
1799 struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
1da177e4 1800
c41f8cbd 1801 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
44cc76f2 1802 return;
1da177e4 1803
d436de8c
MP		 1804 zfcp_sdev = sdev_to_zfcp(sdev);
1805
1da177e4 1806 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
b64ddf96 1807 ZFCP_STATUS_COMMON_ACCESS_BOXED |
b62a8d9b
CS		 1808 ZFCP_STATUS_LUN_SHARED |
1809 ZFCP_STATUS_LUN_READONLY,
1810 &zfcp_sdev->status);
1da177e4 1811
1da177e4
LT		 1812 switch (header->fsf_status) {
1813
1814 case FSF_PORT_HANDLE_NOT_VALID:
ea4a3a6a 1815 zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1");
c41f8cbd 1816 /* fall through */
1da177e4 1817 case FSF_LUN_ALREADY_OPEN:
1da177e4 1818 break;
1da177e4 1819 case FSF_ACCESS_DENIED:
a1ca4831
CS		 1820 zfcp_cfdc_lun_denied(sdev, &header->fsf_status_qual);
1821 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1822 break;
1da177e4 1823 case FSF_PORT_BOXED:
edaed859
SS		 1824 zfcp_erp_set_port_status(zfcp_sdev->port,
1825 ZFCP_STATUS_COMMON_ACCESS_BOXED);
1826 zfcp_erp_port_reopen(zfcp_sdev->port,
ea4a3a6a 1827 ZFCP_STATUS_COMMON_ERP_FAILED, "fsouh_2");
4c571c65 1828 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1829 break;
1da177e4 1830 case FSF_LUN_SHARING_VIOLATION:
a1ca4831 1831 zfcp_cfdc_lun_shrng_vltn(sdev, &header->fsf_status_qual);
c41f8cbd 1832 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1833 break;
1da177e4 1834 case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
c41f8cbd 1835 dev_warn(&adapter->ccw_device->dev,
ff3b24fa
CS		 1836 "No handle is available for LUN "
1837 "0x%016Lx on port 0x%016Lx\n",
b62a8d9b
CS		 1838 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1839 (unsigned long long)zfcp_sdev->port->wwpn);
edaed859 1840 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
c41f8cbd
SS		 1841 /* fall through */
1842 case FSF_INVALID_COMMAND_OPTION:
1843 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1844 break;
1da177e4 1845 case FSF_ADAPTER_STATUS_AVAILABLE:
1da177e4
LT		 1846 switch (header->fsf_status_qual.word[0]) {
1847 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
b62a8d9b 1848 zfcp_fc_test_link(zfcp_sdev->port);
c41f8cbd 1849 /* fall through */
1da177e4 1850 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
c41f8cbd 1851 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1852 break;
1da177e4
LT		 1853 }
1854 break;
1855
1da177e4 1856 case FSF_GOOD:
b62a8d9b
CS		 1857 zfcp_sdev->lun_handle = header->lun_handle;
1858 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
a1ca4831 1859 zfcp_cfdc_open_lun_eval(sdev, bottom);
1da177e4 1860 break;
1da177e4 1861 }
1da177e4
LT		 1862}
1863
c41f8cbd 1864/**
b62a8d9b 1865 * zfcp_fsf_open_lun - open LUN
c41f8cbd
SS		 1866 * @erp_action: pointer to struct zfcp_erp_action
1867 * Returns: 0 on success, error otherwise
1da177e4 1868 */
b62a8d9b 1869int zfcp_fsf_open_lun(struct zfcp_erp_action *erp_action)
1da177e4 1870{
c41f8cbd 1871 struct zfcp_adapter *adapter = erp_action->adapter;
564e1c86 1872 struct zfcp_qdio *qdio = adapter->qdio;
c41f8cbd
SS		 1873 struct zfcp_fsf_req *req;
1874 int retval = -EIO;
1875
44a24cb3 1876 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1877 if (zfcp_qdio_sbal_get(qdio))
1da177e4 1878 goto out;
1da177e4 1879
564e1c86 1880 req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_LUN,
3ec90878 1881 SBAL_SFLAGS0_TYPE_READ,
a4623c46 1882 adapter->pool.erp_req);
09a46c6e 1883
025270f0 1884 if (IS_ERR(req)) {
c41f8cbd
SS		 1885 retval = PTR_ERR(req);
1886 goto out;
1887 }
1888
09a46c6e 1889 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1890 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1da177e4 1891
c41f8cbd 1892 req->qtcb->header.port_handle = erp_action->port->handle;
b62a8d9b
CS		 1893 req->qtcb->bottom.support.fcp_lun = zfcp_scsi_dev_lun(erp_action->sdev);
1894 req->handler = zfcp_fsf_open_lun_handler;
1895 req->data = erp_action->sdev;
c41f8cbd 1896 req->erp_action = erp_action;
e60a6d69 1897 erp_action->fsf_req_id = req->req_id;
c41f8cbd
SS		 1898
1899 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
1900 req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
1901
287ac01a 1902 zfcp_fsf_start_erp_timer(req);
c41f8cbd 1903 retval = zfcp_fsf_req_send(req);
1da177e4 1904 if (retval) {
c41f8cbd 1905 zfcp_fsf_req_free(req);
e60a6d69 1906 erp_action->fsf_req_id = 0;
1da177e4 1907 }
c41f8cbd 1908out:
44a24cb3 1909 spin_unlock_irq(&qdio->req_q_lock);
1da177e4
LT		 1910 return retval;
1911}
1912
b62a8d9b 1913static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req *req)
1da177e4 1914{
b62a8d9b 1915 struct scsi_device *sdev = req->data;
d436de8c 1916 struct zfcp_scsi_dev *zfcp_sdev;
1da177e4 1917
c41f8cbd 1918 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
44cc76f2 1919 return;
1da177e4 1920
d436de8c
MP		 1921 zfcp_sdev = sdev_to_zfcp(sdev);
1922
c41f8cbd 1923 switch (req->qtcb->header.fsf_status) {
1da177e4 1924 case FSF_PORT_HANDLE_NOT_VALID:
ea4a3a6a 1925 zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fscuh_1");
c41f8cbd 1926 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1927 break;
1da177e4 1928 case FSF_LUN_HANDLE_NOT_VALID:
ea4a3a6a 1929 zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2");
c41f8cbd 1930 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1931 break;
1da177e4 1932 case FSF_PORT_BOXED:
edaed859
SS		 1933 zfcp_erp_set_port_status(zfcp_sdev->port,
1934 ZFCP_STATUS_COMMON_ACCESS_BOXED);
1935 zfcp_erp_port_reopen(zfcp_sdev->port,
ea4a3a6a 1936 ZFCP_STATUS_COMMON_ERP_FAILED, "fscuh_3");
4c571c65 1937 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 1938 break;
1da177e4 1939 case FSF_ADAPTER_STATUS_AVAILABLE:
c41f8cbd 1940 switch (req->qtcb->header.fsf_status_qual.word[0]) {
1da177e4 1941 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
b62a8d9b 1942 zfcp_fc_test_link(zfcp_sdev->port);
c41f8cbd 1943 /* fall through */
1da177e4 1944 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
c41f8cbd 1945 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4
LT		 1946 break;
1947 }
1948 break;
1da177e4 1949 case FSF_GOOD:
b62a8d9b 1950 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
1da177e4 1951 break;
1da177e4 1952 }
1da177e4
LT		 1953}
1954
1955/**
b62a8d9b
CS		 1956 * zfcp_fsf_close_LUN - close LUN
1957 * @erp_action: pointer to erp_action triggering the "close LUN"
c41f8cbd 1958 * Returns: 0 on success, error otherwise
1da177e4 1959 */
b62a8d9b 1960int zfcp_fsf_close_lun(struct zfcp_erp_action *erp_action)
1da177e4 1961{
564e1c86 1962 struct zfcp_qdio *qdio = erp_action->adapter->qdio;
b62a8d9b 1963 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
c41f8cbd
SS		 1964 struct zfcp_fsf_req *req;
1965 int retval = -EIO;
1da177e4 1966
44a24cb3 1967 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 1968 if (zfcp_qdio_sbal_get(qdio))
1da177e4 1969 goto out;
09a46c6e 1970
564e1c86 1971 req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_LUN,
3ec90878 1972 SBAL_SFLAGS0_TYPE_READ,
564e1c86 1973 qdio->adapter->pool.erp_req);
09a46c6e 1974
025270f0 1975 if (IS_ERR(req)) {
c41f8cbd
SS		 1976 retval = PTR_ERR(req);
1977 goto out;
1978 }
1da177e4 1979
09a46c6e 1980 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
1674b405 1981 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1da177e4 1982
c41f8cbd 1983 req->qtcb->header.port_handle = erp_action->port->handle;
b62a8d9b
CS		 1984 req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
1985 req->handler = zfcp_fsf_close_lun_handler;
1986 req->data = erp_action->sdev;
c41f8cbd 1987 req->erp_action = erp_action;
e60a6d69 1988 erp_action->fsf_req_id = req->req_id;
fdf23452 1989
287ac01a 1990 zfcp_fsf_start_erp_timer(req);
c41f8cbd
SS		 1991 retval = zfcp_fsf_req_send(req);
1992 if (retval) {
1993 zfcp_fsf_req_free(req);
e60a6d69 1994 erp_action->fsf_req_id = 0;
c41f8cbd
SS		 1995 }
1996out:
44a24cb3 1997 spin_unlock_irq(&qdio->req_q_lock);
c41f8cbd 1998 return retval;
1da177e4
LT		 1999}
2000
c9615858
CS		 2001static void zfcp_fsf_update_lat(struct fsf_latency_record *lat_rec, u32 lat)
2002{
2003 lat_rec->sum += lat;
c41f8cbd
SS		 2004 lat_rec->min = min(lat_rec->min, lat);
2005 lat_rec->max = max(lat_rec->max, lat);
c9615858
CS		 2006}
2007
d9742b42 2008static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
c9615858 2009{
d9742b42
CS		 2010 struct fsf_qual_latency_info *lat_in;
2011 struct latency_cont *lat = NULL;
d436de8c 2012 struct zfcp_scsi_dev *zfcp_sdev;
d9742b42
CS		 2013 struct zfcp_blk_drv_data blktrc;
2014 int ticks = req->adapter->timer_ticks;
c9615858 2015
d9742b42 2016 lat_in = &req->qtcb->prefix.prot_status_qual.latency_info;
c9615858 2017
d9742b42
CS		 2018 blktrc.flags = 0;
2019 blktrc.magic = ZFCP_BLK_DRV_DATA_MAGIC;
2020 if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
2021 blktrc.flags |= ZFCP_BLK_REQ_ERROR;
706eca49 2022 blktrc.inb_usage = 0;
34c2b712 2023 blktrc.outb_usage = req->qdio_req.qdio_outb_usage;
d9742b42 2024
5bbf297c
CS		 2025 if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA &&
2026 !(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
d436de8c 2027 zfcp_sdev = sdev_to_zfcp(scsi->device);
d9742b42
CS		 2028 blktrc.flags |= ZFCP_BLK_LAT_VALID;
2029 blktrc.channel_lat = lat_in->channel_lat * ticks;
2030 blktrc.fabric_lat = lat_in->fabric_lat * ticks;
2031
2032 switch (req->qtcb->bottom.io.data_direction) {
ef3eb71d
FB		 2033 case FSF_DATADIR_DIF_READ_STRIP:
2034 case FSF_DATADIR_DIF_READ_CONVERT:
d9742b42 2035 case FSF_DATADIR_READ:
b62a8d9b 2036 lat = &zfcp_sdev->latencies.read;
d9742b42 2037 break;
ef3eb71d
FB		 2038 case FSF_DATADIR_DIF_WRITE_INSERT:
2039 case FSF_DATADIR_DIF_WRITE_CONVERT:
d9742b42 2040 case FSF_DATADIR_WRITE:
b62a8d9b 2041 lat = &zfcp_sdev->latencies.write;
d9742b42
CS		 2042 break;
2043 case FSF_DATADIR_CMND:
b62a8d9b 2044 lat = &zfcp_sdev->latencies.cmd;
d9742b42
CS		 2045 break;
2046 }
1da177e4 2047
d9742b42 2048 if (lat) {
b62a8d9b 2049 spin_lock(&zfcp_sdev->latencies.lock);
d9742b42
CS		 2050 zfcp_fsf_update_lat(&lat->channel, lat_in->channel_lat);
2051 zfcp_fsf_update_lat(&lat->fabric, lat_in->fabric_lat);
2052 lat->counter++;
b62a8d9b 2053 spin_unlock(&zfcp_sdev->latencies.lock);
d9742b42 2054 }
0997f1c5 2055 }
0997f1c5 2056
d9742b42
CS		 2057 blk_add_driver_data(scsi->request->q, scsi->request, &blktrc,
2058 sizeof(blktrc));
0997f1c5 2059}
0997f1c5 2060
c61b536c 2061static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req)
c41f8cbd 2062{
b62a8d9b
CS		 2063 struct scsi_cmnd *scmnd = req->data;
2064 struct scsi_device *sdev = scmnd->device;
d436de8c 2065 struct zfcp_scsi_dev *zfcp_sdev;
c41f8cbd
SS		 2066 struct fsf_qtcb_header *header = &req->qtcb->header;
2067
c41f8cbd 2068 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
c61b536c 2069 return;
1da177e4 2070
d436de8c
MP		 2071 zfcp_sdev = sdev_to_zfcp(sdev);
2072
c41f8cbd
SS		 2073 switch (header->fsf_status) {
2074 case FSF_HANDLE_MISMATCH:
2075 case FSF_PORT_HANDLE_NOT_VALID:
ea4a3a6a 2076 zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fssfch1");
c41f8cbd
SS		 2077 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2078 break;
2079 case FSF_FCPLUN_NOT_VALID:
2080 case FSF_LUN_HANDLE_NOT_VALID:
ea4a3a6a 2081 zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2");
c41f8cbd 2082 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 2083 break;
c41f8cbd
SS		 2084 case FSF_SERVICE_CLASS_NOT_SUPPORTED:
2085 zfcp_fsf_class_not_supp(req);
1da177e4 2086 break;
c41f8cbd 2087 case FSF_ACCESS_DENIED:
a1ca4831
CS		 2088 zfcp_cfdc_lun_denied(sdev, &header->fsf_status_qual);
2089 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
c41f8cbd
SS		 2090 break;
2091 case FSF_DIRECTION_INDICATOR_NOT_VALID:
2092 dev_err(&req->adapter->ccw_device->dev,
b62a8d9b 2093 "Incorrect direction %d, LUN 0x%016Lx on port "
ff3b24fa 2094 "0x%016Lx closed\n",
c41f8cbd 2095 req->qtcb->bottom.io.data_direction,
b62a8d9b
CS		 2096 (unsigned long long)zfcp_scsi_dev_lun(sdev),
2097 (unsigned long long)zfcp_sdev->port->wwpn);
2098 zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
ea4a3a6a 2099 "fssfch3");
c41f8cbd
SS		 2100 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2101 break;
2102 case FSF_CMND_LENGTH_NOT_VALID:
2103 dev_err(&req->adapter->ccw_device->dev,
b62a8d9b 2104 "Incorrect CDB length %d, LUN 0x%016Lx on "
ff3b24fa 2105 "port 0x%016Lx closed\n",
c41f8cbd 2106 req->qtcb->bottom.io.fcp_cmnd_length,
b62a8d9b
CS		 2107 (unsigned long long)zfcp_scsi_dev_lun(sdev),
2108 (unsigned long long)zfcp_sdev->port->wwpn);
2109 zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
ea4a3a6a 2110 "fssfch4");
c41f8cbd
SS		 2111 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2112 break;
2113 case FSF_PORT_BOXED:
edaed859
SS		 2114 zfcp_erp_set_port_status(zfcp_sdev->port,
2115 ZFCP_STATUS_COMMON_ACCESS_BOXED);
2116 zfcp_erp_port_reopen(zfcp_sdev->port,
ea4a3a6a 2117 ZFCP_STATUS_COMMON_ERP_FAILED, "fssfch5");
4c571c65 2118 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
c41f8cbd
SS		 2119 break;
2120 case FSF_LUN_BOXED:
edaed859
SS		 2121 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
2122 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
ea4a3a6a 2123 "fssfch6");
4c571c65 2124 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
c41f8cbd
SS		 2125 break;
2126 case FSF_ADAPTER_STATUS_AVAILABLE:
2127 if (header->fsf_status_qual.word[0] ==
2128 FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
b62a8d9b 2129 zfcp_fc_test_link(zfcp_sdev->port);
c41f8cbd 2130 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1da177e4 2131 break;
1da177e4 2132 }
c61b536c
CS		 2133}
2134
2135static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req *req)
2136{
2137 struct scsi_cmnd *scpnt;
2138 struct fcp_resp_with_ext *fcp_rsp;
2139 unsigned long flags;
2140
c61b536c
CS		 2141 read_lock_irqsave(&req->adapter->abort_lock, flags);
2142
2143 scpnt = req->data;
2144 if (unlikely(!scpnt)) {
2145 read_unlock_irqrestore(&req->adapter->abort_lock, flags);
2146 return;
c41f8cbd 2147 }
c61b536c 2148
5bfb2c31
SS		 2149 zfcp_fsf_fcp_handler_common(req);
2150
c61b536c
CS		 2151 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
2152 set_host_byte(scpnt, DID_TRANSPORT_DISRUPTED);
2153 goto skip_fsfstatus;
2154 }
2155
2156 switch (req->qtcb->header.fsf_status) {
2157 case FSF_INCONSISTENT_PROT_DATA:
2158 case FSF_INVALID_PROT_PARM:
2159 set_host_byte(scpnt, DID_ERROR);
2160 goto skip_fsfstatus;
2161 case FSF_BLOCK_GUARD_CHECK_FAILURE:
2162 zfcp_scsi_dif_sense_error(scpnt, 0x1);
2163 goto skip_fsfstatus;
2164 case FSF_APP_TAG_CHECK_FAILURE:
2165 zfcp_scsi_dif_sense_error(scpnt, 0x2);
2166 goto skip_fsfstatus;
2167 case FSF_REF_TAG_CHECK_FAILURE:
2168 zfcp_scsi_dif_sense_error(scpnt, 0x3);
2169 goto skip_fsfstatus;
2170 }
2171 fcp_rsp = (struct fcp_resp_with_ext *) &req->qtcb->bottom.io.fcp_rsp;
2172 zfcp_fc_eval_fcp_rsp(fcp_rsp, scpnt);
2173
2174skip_fsfstatus:
2175 zfcp_fsf_req_trace(req, scpnt);
250a1352 2176 zfcp_dbf_scsi_result(scpnt, req);
c61b536c
CS		 2177
2178 scpnt->host_scribble = NULL;
2179 (scpnt->scsi_done) (scpnt);
2180 /*
2181 * We must hold this lock until scsi_done has been called.
2182 * Otherwise we may call scsi_done after abort regarding this
2183 * command has completed.
2184 * Note: scsi_done must not block!
2185 */
2186 read_unlock_irqrestore(&req->adapter->abort_lock, flags);
1da177e4
LT		 2187}
2188
ef3eb71d
FB		 2189static int zfcp_fsf_set_data_dir(struct scsi_cmnd *scsi_cmnd, u32 *data_dir)
2190{
2191 switch (scsi_get_prot_op(scsi_cmnd)) {
2192 case SCSI_PROT_NORMAL:
2193 switch (scsi_cmnd->sc_data_direction) {
2194 case DMA_NONE:
2195 *data_dir = FSF_DATADIR_CMND;
2196 break;
2197 case DMA_FROM_DEVICE:
2198 *data_dir = FSF_DATADIR_READ;
2199 break;
2200 case DMA_TO_DEVICE:
2201 *data_dir = FSF_DATADIR_WRITE;
2202 break;
2203 case DMA_BIDIRECTIONAL:
2204 return -EINVAL;
2205 }
2206 break;
2207
2208 case SCSI_PROT_READ_STRIP:
2209 *data_dir = FSF_DATADIR_DIF_READ_STRIP;
2210 break;
2211 case SCSI_PROT_WRITE_INSERT:
2212 *data_dir = FSF_DATADIR_DIF_WRITE_INSERT;
2213 break;
2214 case SCSI_PROT_READ_PASS:
2215 *data_dir = FSF_DATADIR_DIF_READ_CONVERT;
2216 break;
2217 case SCSI_PROT_WRITE_PASS:
2218 *data_dir = FSF_DATADIR_DIF_WRITE_CONVERT;
2219 break;
2220 default:
2221 return -EINVAL;
2222 }
2223
2224 return 0;
2225}
2226
c41f8cbd 2227/**
b62a8d9b 2228 * zfcp_fsf_fcp_cmnd - initiate an FCP command (for a SCSI command)
c41f8cbd 2229 * @scsi_cmnd: scsi command to be sent
1da177e4 2230 */
b62a8d9b 2231int zfcp_fsf_fcp_cmnd(struct scsi_cmnd *scsi_cmnd)
1da177e4 2232{
c41f8cbd 2233 struct zfcp_fsf_req *req;
4318e08c 2234 struct fcp_cmnd *fcp_cmnd;
3ec90878 2235 u8 sbtype = SBAL_SFLAGS0_TYPE_READ;
86a9668a 2236 int retval = -EIO;
b62a8d9b
CS		 2237 struct scsi_device *sdev = scsi_cmnd->device;
2238 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
2239 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
564e1c86 2240 struct zfcp_qdio *qdio = adapter->qdio;
ef3eb71d 2241 struct fsf_qtcb_bottom_io *io;
e55f8753 2242 unsigned long flags;
1da177e4 2243
b62a8d9b 2244 if (unlikely(!(atomic_read(&zfcp_sdev->status) &
c41f8cbd
SS		 2245 ZFCP_STATUS_COMMON_UNBLOCKED)))
2246 return -EBUSY;
1da177e4 2247
e55f8753 2248 spin_lock_irqsave(&qdio->req_q_lock, flags);
706eca49 2249 if (atomic_read(&qdio->req_q_free) <= 0) {
564e1c86 2250 atomic_inc(&qdio->req_q_full);
c41f8cbd 2251 goto out;
8fdf30d5 2252 }
09a46c6e 2253
1674b405 2254 if (scsi_cmnd->sc_data_direction == DMA_TO_DEVICE)
3ec90878 2255 sbtype = SBAL_SFLAGS0_TYPE_WRITE;
1674b405 2256
564e1c86 2257 req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND,
1674b405 2258 sbtype, adapter->pool.scsi_req);
09a46c6e 2259
025270f0 2260 if (IS_ERR(req)) {
c41f8cbd
SS		 2261 retval = PTR_ERR(req);
2262 goto out;
2263 }
2264
ef3eb71d
FB		 2265 scsi_cmnd->host_scribble = (unsigned char *) req->req_id;
2266
2267 io = &req->qtcb->bottom.io;
09a46c6e 2268 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
c41f8cbd 2269 req->data = scsi_cmnd;
c61b536c 2270 req->handler = zfcp_fsf_fcp_cmnd_handler;
b62a8d9b
CS		 2271 req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
2272 req->qtcb->header.port_handle = zfcp_sdev->port->handle;
ef3eb71d
FB		 2273 io->service_class = FSF_CLASS_3;
2274 io->fcp_cmnd_length = FCP_CMND_LEN;
c41f8cbd 2275
ef3eb71d
FB		 2276 if (scsi_get_prot_op(scsi_cmnd) != SCSI_PROT_NORMAL) {
2277 io->data_block_length = scsi_cmnd->device->sector_size;
2278 io->ref_tag_value = scsi_get_lba(scsi_cmnd) & 0xFFFFFFFF;
1da177e4
LT		 2279 }
2280
cc405ace
SM		 2281 if (zfcp_fsf_set_data_dir(scsi_cmnd, &io->data_direction))
2282 goto failed_scsi_cmnd;
ef3eb71d 2283
4318e08c 2284 fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
2443c8b2 2285 zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd, 0);
1da177e4 2286
ef3eb71d
FB		 2287 if (scsi_prot_sg_count(scsi_cmnd)) {
2288 zfcp_qdio_set_data_div(qdio, &req->qdio_req,
2289 scsi_prot_sg_count(scsi_cmnd));
86a9668a
SS		 2290 retval = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req,
2291 scsi_prot_sglist(scsi_cmnd));
2292 if (retval)
2293 goto failed_scsi_cmnd;
2294 io->prot_data_length = zfcp_qdio_real_bytes(
ef3eb71d 2295 scsi_prot_sglist(scsi_cmnd));
ef3eb71d
FB		 2296 }
2297
86a9668a
SS		 2298 retval = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req,
2299 scsi_sglist(scsi_cmnd));
2300 if (unlikely(retval))
c41f8cbd 2301 goto failed_scsi_cmnd;
1da177e4 2302
ef3eb71d 2303 zfcp_qdio_set_sbale_last(adapter->qdio, &req->qdio_req);
86a9668a
SS		 2304 if (zfcp_adapter_multi_buffer_active(adapter))
2305 zfcp_qdio_set_scount(qdio, &req->qdio_req);
ef3eb71d 2306
c41f8cbd
SS		 2307 retval = zfcp_fsf_req_send(req);
2308 if (unlikely(retval))
2309 goto failed_scsi_cmnd;
1da177e4 2310
c41f8cbd 2311 goto out;
1da177e4 2312
c41f8cbd 2313failed_scsi_cmnd:
c41f8cbd
SS		 2314 zfcp_fsf_req_free(req);
2315 scsi_cmnd->host_scribble = NULL;
2316out:
e55f8753 2317 spin_unlock_irqrestore(&qdio->req_q_lock, flags);
c41f8cbd 2318 return retval;
1da177e4
LT		 2319}
2320
c61b536c
CS		 2321static void zfcp_fsf_fcp_task_mgmt_handler(struct zfcp_fsf_req *req)
2322{
2323 struct fcp_resp_with_ext *fcp_rsp;
2324 struct fcp_resp_rsp_info *rsp_info;
2325
2326 zfcp_fsf_fcp_handler_common(req);
2327
2328 fcp_rsp = (struct fcp_resp_with_ext *) &req->qtcb->bottom.io.fcp_rsp;
2329 rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
2330
2331 if ((rsp_info->rsp_code != FCP_TMF_CMPL) ||
2332 (req->status & ZFCP_STATUS_FSFREQ_ERROR))
2333 req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
2334}
2335
1da177e4 2336/**
b62a8d9b
CS		 2337 * zfcp_fsf_fcp_task_mgmt - send SCSI task management command
2338 * @scmnd: SCSI command to send the task management command for
c41f8cbd 2339 * @tm_flags: unsigned byte for task management flags
c41f8cbd 2340 * Returns: on success pointer to struct fsf_req, NULL otherwise
1da177e4 2341 */
b62a8d9b
CS		 2342struct zfcp_fsf_req *zfcp_fsf_fcp_task_mgmt(struct scsi_cmnd *scmnd,
2343 u8 tm_flags)
1da177e4 2344{
c41f8cbd 2345 struct zfcp_fsf_req *req = NULL;
4318e08c 2346 struct fcp_cmnd *fcp_cmnd;
b62a8d9b
CS		 2347 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scmnd->device);
2348 struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
1da177e4 2349
b62a8d9b 2350 if (unlikely(!(atomic_read(&zfcp_sdev->status) &
c41f8cbd
SS		 2351 ZFCP_STATUS_COMMON_UNBLOCKED)))
2352 return NULL;
1da177e4 2353
44a24cb3 2354 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 2355 if (zfcp_qdio_sbal_get(qdio))
c41f8cbd 2356 goto out;
09a46c6e 2357
564e1c86 2358 req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND,
3ec90878 2359 SBAL_SFLAGS0_TYPE_WRITE,
564e1c86 2360 qdio->adapter->pool.scsi_req);
09a46c6e 2361
633528c3
SS		 2362 if (IS_ERR(req)) {
2363 req = NULL;
c41f8cbd 2364 goto out;
633528c3 2365 }
1da177e4 2366
b62a8d9b 2367 req->data = scmnd;
c61b536c 2368 req->handler = zfcp_fsf_fcp_task_mgmt_handler;
b62a8d9b
CS		 2369 req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
2370 req->qtcb->header.port_handle = zfcp_sdev->port->handle;
c41f8cbd
SS		 2371 req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
2372 req->qtcb->bottom.io.service_class = FSF_CLASS_3;
4318e08c 2373 req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN;
c41f8cbd 2374
1674b405 2375 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
1da177e4 2376
4318e08c 2377 fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
2443c8b2 2378 zfcp_fc_scsi_to_fcp(fcp_cmnd, scmnd, tm_flags);
1da177e4 2379
c41f8cbd
SS		 2380 zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
2381 if (!zfcp_fsf_req_send(req))
2382 goto out;
1da177e4 2383
c41f8cbd
SS		 2384 zfcp_fsf_req_free(req);
2385 req = NULL;
2386out:
44a24cb3 2387 spin_unlock_irq(&qdio->req_q_lock);
c41f8cbd
SS		 2388 return req;
2389}
1da177e4 2390
c41f8cbd
SS		 2391static void zfcp_fsf_control_file_handler(struct zfcp_fsf_req *req)
2392{
1da177e4
LT		 2393}
2394
c41f8cbd
SS		 2395/**
2396 * zfcp_fsf_control_file - control file upload/download
2397 * @adapter: pointer to struct zfcp_adapter
2398 * @fsf_cfdc: pointer to struct zfcp_fsf_cfdc
2399 * Returns: on success pointer to struct zfcp_fsf_req, NULL otherwise
1da177e4 2400 */
c41f8cbd
SS		 2401struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
2402 struct zfcp_fsf_cfdc *fsf_cfdc)
1da177e4 2403{
564e1c86 2404 struct zfcp_qdio *qdio = adapter->qdio;
c41f8cbd
SS		 2405 struct zfcp_fsf_req *req = NULL;
2406 struct fsf_qtcb_bottom_support *bottom;
86a9668a 2407 int retval = -EIO;
3ec90878 2408 u8 direction;
c41f8cbd
SS		 2409
2410 if (!(adapter->adapter_features & FSF_FEATURE_CFDC))
2411 return ERR_PTR(-EOPNOTSUPP);
2412
2413 switch (fsf_cfdc->command) {
2414 case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
3ec90878 2415 direction = SBAL_SFLAGS0_TYPE_WRITE;
c41f8cbd
SS		 2416 break;
2417 case FSF_QTCB_UPLOAD_CONTROL_FILE:
3ec90878 2418 direction = SBAL_SFLAGS0_TYPE_READ;
c41f8cbd
SS		 2419 break;
2420 default:
2421 return ERR_PTR(-EINVAL);
2422 }
1da177e4 2423
44a24cb3 2424 spin_lock_irq(&qdio->req_q_lock);
6b9e1520 2425 if (zfcp_qdio_sbal_get(qdio))
c41f8cbd 2426 goto out;
1da177e4 2427
1674b405 2428 req = zfcp_fsf_req_create(qdio, fsf_cfdc->command, direction, NULL);
025270f0 2429 if (IS_ERR(req)) {
c41f8cbd
SS		 2430 retval = -EPERM;
2431 goto out;
2432 }
1da177e4 2433
c41f8cbd 2434 req->handler = zfcp_fsf_control_file_handler;
1da177e4 2435
c41f8cbd
SS		 2436 bottom = &req->qtcb->bottom.support;
2437 bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
2438 bottom->option = fsf_cfdc->option;
8a36e453 2439
86a9668a 2440 retval = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, fsf_cfdc->sg);
01b04759 2441
86a9668a
SS		 2442 if (retval ||
2443 (zfcp_qdio_real_bytes(fsf_cfdc->sg) != ZFCP_CFDC_MAX_SIZE)) {
c41f8cbd 2444 zfcp_fsf_req_free(req);
86a9668a 2445 retval = -EIO;
c41f8cbd
SS		 2446 goto out;
2447 }
86a9668a
SS		 2448 zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
2449 if (zfcp_adapter_multi_buffer_active(adapter))
2450 zfcp_qdio_set_scount(qdio, &req->qdio_req);
1da177e4 2451
c41f8cbd
SS		 2452 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2453 retval = zfcp_fsf_req_send(req);
2454out:
44a24cb3 2455 spin_unlock_irq(&qdio->req_q_lock);
8a36e453 2456
c41f8cbd 2457 if (!retval) {
058b8647 2458 wait_for_completion(&req->completion);
c41f8cbd 2459 return req;
1da177e4 2460 }
c41f8cbd 2461 return ERR_PTR(retval);
1da177e4 2462}
bd63eaf4
SS		 2463
2464/**
2465 * zfcp_fsf_reqid_check - validate req_id contained in SBAL returned by QDIO
2466 * @adapter: pointer to struct zfcp_adapter
2467 * @sbal_idx: response queue index of SBAL to be processed
2468 */
564e1c86 2469void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
bd63eaf4 2470{
564e1c86 2471 struct zfcp_adapter *adapter = qdio->adapter;
706eca49 2472 struct qdio_buffer *sbal = qdio->res_q[sbal_idx];
bd63eaf4
SS		 2473 struct qdio_buffer_element *sbale;
2474 struct zfcp_fsf_req *fsf_req;
b6bd2fb9 2475 unsigned long req_id;
bd63eaf4
SS		 2476 int idx;
2477
2478 for (idx = 0; idx < QDIO_MAX_ELEMENTS_PER_BUFFER; idx++) {
2479
2480 sbale = &sbal->element[idx];
2481 req_id = (unsigned long) sbale->addr;
b6bd2fb9 2482 fsf_req = zfcp_reqlist_find_rm(adapter->req_list, req_id);
bd63eaf4 2483
339f4f4e 2484 if (!fsf_req) {
bd63eaf4
SS		 2485 /*
2486 * Unknown request means that we have potentially memory
2487 * corruption and must stop the machine immediately.
2488 */
339f4f4e 2489 zfcp_qdio_siosl(adapter);
bd63eaf4
SS		 2490 panic("error: unknown req_id (%lx) on adapter %s.\n",
2491 req_id, dev_name(&adapter->ccw_device->dev));
339f4f4e 2492 }
bd63eaf4 2493
34c2b712 2494 fsf_req->qdio_req.sbal_response = sbal_idx;
bd63eaf4
SS		 2495 zfcp_fsf_req_complete(fsf_req);
2496
3ec90878 2497 if (likely(sbale->eflags & SBAL_EFLAGS_LAST_ENTRY))
bd63eaf4
SS		 2498 break;
2499 }
2500}
a54ca0f6
SS		 2501
2502struct zfcp_fsf_req *zfcp_fsf_get_req(struct zfcp_qdio *qdio,
2503 struct qdio_buffer *sbal)
2504{
2505 struct qdio_buffer_element *sbale = &sbal->element[0];
2506 u64 req_id = (unsigned long) sbale->addr;
2507
2508 return zfcp_reqlist_find(qdio->adapter->req_list, req_id);
2509}
kernel source for telekom puls (alcatel/mediatek)