4 * Implementation of FSF commands.
6 * Copyright IBM Corp. 2002, 2017
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/blktrace_api.h>
13 #include <linux/slab.h>
14 #include <scsi/fc/fc_els.h>
18 #include "zfcp_qdio.h"
19 #include "zfcp_reqlist.h"
21 struct kmem_cache
*zfcp_fsf_qtcb_cache
;
23 static void zfcp_fsf_request_timeout_handler(unsigned long data
)
25 struct zfcp_adapter
*adapter
= (struct zfcp_adapter
*) data
;
26 zfcp_qdio_siosl(adapter
);
27 zfcp_erp_adapter_reopen(adapter
, ZFCP_STATUS_COMMON_ERP_FAILED
,
31 static void zfcp_fsf_start_timer(struct zfcp_fsf_req
*fsf_req
,
32 unsigned long timeout
)
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
);
40 static void zfcp_fsf_start_erp_timer(struct zfcp_fsf_req
*fsf_req
)
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
);
49 /* association between FSF command and FSF QTCB type */
50 static 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
66 static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req
*req
)
68 dev_err(&req
->adapter
->ccw_device
->dev
, "FCP device not "
69 "operational because of an unsupported FC class\n");
70 zfcp_erp_adapter_shutdown(req
->adapter
, 0, "fscns_1");
71 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
75 * zfcp_fsf_req_free - free memory used by fsf request
76 * @fsf_req: pointer to struct zfcp_fsf_req
78 void zfcp_fsf_req_free(struct zfcp_fsf_req
*req
)
80 if (likely(req
->pool
)) {
81 if (likely(req
->qtcb
))
82 mempool_free(req
->qtcb
, req
->adapter
->pool
.qtcb_pool
);
83 mempool_free(req
, req
->pool
);
87 if (likely(req
->qtcb
))
88 kmem_cache_free(zfcp_fsf_qtcb_cache
, req
->qtcb
);
92 static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req
*req
)
95 struct fsf_status_read_buffer
*sr_buf
= req
->data
;
96 struct zfcp_adapter
*adapter
= req
->adapter
;
97 struct zfcp_port
*port
;
98 int d_id
= ntoh24(sr_buf
->d_id
);
100 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
101 list_for_each_entry(port
, &adapter
->port_list
, list
)
102 if (port
->d_id
== d_id
) {
103 zfcp_erp_port_reopen(port
, 0, "fssrpc1");
106 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
109 static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req
*req
,
110 struct fsf_link_down_info
*link_down
)
112 struct zfcp_adapter
*adapter
= req
->adapter
;
114 if (atomic_read(&adapter
->status
) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
)
117 atomic_or(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
, &adapter
->status
);
119 zfcp_scsi_schedule_rports_block(adapter
);
124 switch (link_down
->error_code
) {
125 case FSF_PSQ_LINK_NO_LIGHT
:
126 dev_warn(&req
->adapter
->ccw_device
->dev
,
127 "There is no light signal from the local "
128 "fibre channel cable\n");
130 case FSF_PSQ_LINK_WRAP_PLUG
:
131 dev_warn(&req
->adapter
->ccw_device
->dev
,
132 "There is a wrap plug instead of a fibre "
135 case FSF_PSQ_LINK_NO_FCP
:
136 dev_warn(&req
->adapter
->ccw_device
->dev
,
137 "The adjacent fibre channel node does not "
140 case FSF_PSQ_LINK_FIRMWARE_UPDATE
:
141 dev_warn(&req
->adapter
->ccw_device
->dev
,
142 "The FCP device is suspended because of a "
143 "firmware update\n");
145 case FSF_PSQ_LINK_INVALID_WWPN
:
146 dev_warn(&req
->adapter
->ccw_device
->dev
,
147 "The FCP device detected a WWPN that is "
148 "duplicate or not valid\n");
150 case FSF_PSQ_LINK_NO_NPIV_SUPPORT
:
151 dev_warn(&req
->adapter
->ccw_device
->dev
,
152 "The fibre channel fabric does not support NPIV\n");
154 case FSF_PSQ_LINK_NO_FCP_RESOURCES
:
155 dev_warn(&req
->adapter
->ccw_device
->dev
,
156 "The FCP adapter cannot support more NPIV ports\n");
158 case FSF_PSQ_LINK_NO_FABRIC_RESOURCES
:
159 dev_warn(&req
->adapter
->ccw_device
->dev
,
160 "The adjacent switch cannot support "
161 "more NPIV ports\n");
163 case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE
:
164 dev_warn(&req
->adapter
->ccw_device
->dev
,
165 "The FCP adapter could not log in to the "
166 "fibre channel fabric\n");
168 case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED
:
169 dev_warn(&req
->adapter
->ccw_device
->dev
,
170 "The WWPN assignment file on the FCP adapter "
171 "has been damaged\n");
173 case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED
:
174 dev_warn(&req
->adapter
->ccw_device
->dev
,
175 "The mode table on the FCP adapter "
176 "has been damaged\n");
178 case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT
:
179 dev_warn(&req
->adapter
->ccw_device
->dev
,
180 "All NPIV ports on the FCP adapter have "
184 dev_warn(&req
->adapter
->ccw_device
->dev
,
185 "The link between the FCP adapter and "
186 "the FC fabric is down\n");
189 zfcp_erp_set_adapter_status(adapter
, ZFCP_STATUS_COMMON_ERP_FAILED
);
192 static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req
*req
)
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
;
198 switch (sr_buf
->status_subtype
) {
199 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK
:
200 case FSF_STATUS_READ_SUB_FDISC_FAILED
:
201 zfcp_fsf_link_down_info_eval(req
, ldi
);
203 case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE
:
204 zfcp_fsf_link_down_info_eval(req
, NULL
);
208 static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req
*req
)
210 struct zfcp_adapter
*adapter
= req
->adapter
;
211 struct fsf_status_read_buffer
*sr_buf
= req
->data
;
213 if (req
->status
& ZFCP_STATUS_FSFREQ_DISMISSED
) {
214 zfcp_dbf_hba_fsf_uss("fssrh_1", req
);
215 mempool_free(virt_to_page(sr_buf
), adapter
->pool
.sr_data
);
216 zfcp_fsf_req_free(req
);
220 zfcp_dbf_hba_fsf_uss("fssrh_4", req
);
222 switch (sr_buf
->status_type
) {
223 case FSF_STATUS_READ_PORT_CLOSED
:
224 zfcp_fsf_status_read_port_closed(req
);
226 case FSF_STATUS_READ_INCOMING_ELS
:
227 zfcp_fc_incoming_els(req
);
229 case FSF_STATUS_READ_SENSE_DATA_AVAIL
:
231 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD
:
232 dev_warn(&adapter
->ccw_device
->dev
,
233 "The error threshold for checksum statistics "
234 "has been exceeded\n");
235 zfcp_dbf_hba_bit_err("fssrh_3", req
);
237 case FSF_STATUS_READ_LINK_DOWN
:
238 zfcp_fsf_status_read_link_down(req
);
239 zfcp_fc_enqueue_event(adapter
, FCH_EVT_LINKDOWN
, 0);
241 case FSF_STATUS_READ_LINK_UP
:
242 dev_info(&adapter
->ccw_device
->dev
,
243 "The local link has been restored\n");
244 /* All ports should be marked as ready to run again */
245 zfcp_erp_set_adapter_status(adapter
,
246 ZFCP_STATUS_COMMON_RUNNING
);
247 zfcp_erp_adapter_reopen(adapter
,
248 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
|
249 ZFCP_STATUS_COMMON_ERP_FAILED
,
251 zfcp_fc_enqueue_event(adapter
, FCH_EVT_LINKUP
, 0);
254 case FSF_STATUS_READ_NOTIFICATION_LOST
:
255 if (sr_buf
->status_subtype
& FSF_STATUS_READ_SUB_INCOMING_ELS
)
256 zfcp_fc_conditional_port_scan(adapter
);
258 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT
:
259 adapter
->adapter_features
= sr_buf
->payload
.word
[0];
263 mempool_free(virt_to_page(sr_buf
), adapter
->pool
.sr_data
);
264 zfcp_fsf_req_free(req
);
266 atomic_inc(&adapter
->stat_miss
);
267 queue_work(adapter
->work_queue
, &adapter
->stat_work
);
270 static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req
*req
)
272 switch (req
->qtcb
->header
.fsf_status_qual
.word
[0]) {
273 case FSF_SQ_FCP_RSP_AVAILABLE
:
274 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
275 case FSF_SQ_NO_RETRY_POSSIBLE
:
276 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
278 case FSF_SQ_COMMAND_ABORTED
:
280 case FSF_SQ_NO_RECOM
:
281 dev_err(&req
->adapter
->ccw_device
->dev
,
282 "The FCP adapter reported a problem "
283 "that cannot be recovered\n");
284 zfcp_qdio_siosl(req
->adapter
);
285 zfcp_erp_adapter_shutdown(req
->adapter
, 0, "fsfsqe1");
288 /* all non-return stats set FSFREQ_ERROR*/
289 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
292 static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req
*req
)
294 if (unlikely(req
->status
& ZFCP_STATUS_FSFREQ_ERROR
))
297 switch (req
->qtcb
->header
.fsf_status
) {
298 case FSF_UNKNOWN_COMMAND
:
299 dev_err(&req
->adapter
->ccw_device
->dev
,
300 "The FCP adapter does not recognize the command 0x%x\n",
301 req
->qtcb
->header
.fsf_command
);
302 zfcp_erp_adapter_shutdown(req
->adapter
, 0, "fsfse_1");
303 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
305 case FSF_ADAPTER_STATUS_AVAILABLE
:
306 zfcp_fsf_fsfstatus_qual_eval(req
);
311 static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req
*req
)
313 struct zfcp_adapter
*adapter
= req
->adapter
;
314 struct fsf_qtcb
*qtcb
= req
->qtcb
;
315 union fsf_prot_status_qual
*psq
= &qtcb
->prefix
.prot_status_qual
;
317 zfcp_dbf_hba_fsf_response(req
);
319 if (req
->status
& ZFCP_STATUS_FSFREQ_DISMISSED
) {
320 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
324 switch (qtcb
->prefix
.prot_status
) {
326 case FSF_PROT_FSF_STATUS_PRESENTED
:
328 case FSF_PROT_QTCB_VERSION_ERROR
:
329 dev_err(&adapter
->ccw_device
->dev
,
330 "QTCB version 0x%x not supported by FCP adapter "
331 "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION
,
332 psq
->word
[0], psq
->word
[1]);
333 zfcp_erp_adapter_shutdown(adapter
, 0, "fspse_1");
335 case FSF_PROT_ERROR_STATE
:
336 case FSF_PROT_SEQ_NUMB_ERROR
:
337 zfcp_erp_adapter_reopen(adapter
, 0, "fspse_2");
338 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
340 case FSF_PROT_UNSUPP_QTCB_TYPE
:
341 dev_err(&adapter
->ccw_device
->dev
,
342 "The QTCB type is not supported by the FCP adapter\n");
343 zfcp_erp_adapter_shutdown(adapter
, 0, "fspse_3");
345 case FSF_PROT_HOST_CONNECTION_INITIALIZING
:
346 atomic_or(ZFCP_STATUS_ADAPTER_HOST_CON_INIT
,
349 case FSF_PROT_DUPLICATE_REQUEST_ID
:
350 dev_err(&adapter
->ccw_device
->dev
,
351 "0x%Lx is an ambiguous request identifier\n",
352 (unsigned long long)qtcb
->bottom
.support
.req_handle
);
353 zfcp_erp_adapter_shutdown(adapter
, 0, "fspse_4");
355 case FSF_PROT_LINK_DOWN
:
356 zfcp_fsf_link_down_info_eval(req
, &psq
->link_down_info
);
357 /* go through reopen to flush pending requests */
358 zfcp_erp_adapter_reopen(adapter
, 0, "fspse_6");
360 case FSF_PROT_REEST_QUEUE
:
361 /* All ports should be marked as ready to run again */
362 zfcp_erp_set_adapter_status(adapter
,
363 ZFCP_STATUS_COMMON_RUNNING
);
364 zfcp_erp_adapter_reopen(adapter
,
365 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
|
366 ZFCP_STATUS_COMMON_ERP_FAILED
,
370 dev_err(&adapter
->ccw_device
->dev
,
371 "0x%x is not a valid transfer protocol status\n",
372 qtcb
->prefix
.prot_status
);
373 zfcp_qdio_siosl(adapter
);
374 zfcp_erp_adapter_shutdown(adapter
, 0, "fspse_9");
376 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
380 * zfcp_fsf_req_complete - process completion of a FSF request
381 * @fsf_req: The FSF request that has been completed.
383 * When a request has been completed either from the FCP adapter,
384 * or it has been dismissed due to a queue shutdown, this function
385 * is called to process the completion status and trigger further
386 * events related to the FSF request.
388 static void zfcp_fsf_req_complete(struct zfcp_fsf_req
*req
)
390 if (unlikely(req
->fsf_command
== FSF_QTCB_UNSOLICITED_STATUS
)) {
391 zfcp_fsf_status_read_handler(req
);
395 del_timer(&req
->timer
);
396 zfcp_fsf_protstatus_eval(req
);
397 zfcp_fsf_fsfstatus_eval(req
);
401 zfcp_erp_notify(req
->erp_action
, 0);
403 if (likely(req
->status
& ZFCP_STATUS_FSFREQ_CLEANUP
))
404 zfcp_fsf_req_free(req
);
406 complete(&req
->completion
);
410 * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
411 * @adapter: pointer to struct zfcp_adapter
413 * Never ever call this without shutting down the adapter first.
414 * Otherwise the adapter would continue using and corrupting s390 storage.
415 * Included BUG_ON() call to ensure this is done.
416 * ERP is supposed to be the only user of this function.
418 void zfcp_fsf_req_dismiss_all(struct zfcp_adapter
*adapter
)
420 struct zfcp_fsf_req
*req
, *tmp
;
421 LIST_HEAD(remove_queue
);
423 BUG_ON(atomic_read(&adapter
->status
) & ZFCP_STATUS_ADAPTER_QDIOUP
);
424 zfcp_reqlist_move(adapter
->req_list
, &remove_queue
);
426 list_for_each_entry_safe(req
, tmp
, &remove_queue
, list
) {
427 list_del(&req
->list
);
428 req
->status
|= ZFCP_STATUS_FSFREQ_DISMISSED
;
429 zfcp_fsf_req_complete(req
);
433 #define ZFCP_FSF_PORTSPEED_1GBIT (1 << 0)
434 #define ZFCP_FSF_PORTSPEED_2GBIT (1 << 1)
435 #define ZFCP_FSF_PORTSPEED_4GBIT (1 << 2)
436 #define ZFCP_FSF_PORTSPEED_10GBIT (1 << 3)
437 #define ZFCP_FSF_PORTSPEED_8GBIT (1 << 4)
438 #define ZFCP_FSF_PORTSPEED_16GBIT (1 << 5)
439 #define ZFCP_FSF_PORTSPEED_NOT_NEGOTIATED (1 << 15)
441 static u32
zfcp_fsf_convert_portspeed(u32 fsf_speed
)
444 if (fsf_speed
& ZFCP_FSF_PORTSPEED_1GBIT
)
445 fdmi_speed
|= FC_PORTSPEED_1GBIT
;
446 if (fsf_speed
& ZFCP_FSF_PORTSPEED_2GBIT
)
447 fdmi_speed
|= FC_PORTSPEED_2GBIT
;
448 if (fsf_speed
& ZFCP_FSF_PORTSPEED_4GBIT
)
449 fdmi_speed
|= FC_PORTSPEED_4GBIT
;
450 if (fsf_speed
& ZFCP_FSF_PORTSPEED_10GBIT
)
451 fdmi_speed
|= FC_PORTSPEED_10GBIT
;
452 if (fsf_speed
& ZFCP_FSF_PORTSPEED_8GBIT
)
453 fdmi_speed
|= FC_PORTSPEED_8GBIT
;
454 if (fsf_speed
& ZFCP_FSF_PORTSPEED_16GBIT
)
455 fdmi_speed
|= FC_PORTSPEED_16GBIT
;
456 if (fsf_speed
& ZFCP_FSF_PORTSPEED_NOT_NEGOTIATED
)
457 fdmi_speed
|= FC_PORTSPEED_NOT_NEGOTIATED
;
461 static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req
*req
)
463 struct fsf_qtcb_bottom_config
*bottom
= &req
->qtcb
->bottom
.config
;
464 struct zfcp_adapter
*adapter
= req
->adapter
;
465 struct Scsi_Host
*shost
= adapter
->scsi_host
;
466 struct fc_els_flogi
*nsp
, *plogi
;
468 /* adjust pointers for missing command code */
469 nsp
= (struct fc_els_flogi
*) ((u8
*)&bottom
->nport_serv_param
471 plogi
= (struct fc_els_flogi
*) ((u8
*)&bottom
->plogi_payload
475 memcpy(req
->data
, bottom
, sizeof(*bottom
));
477 fc_host_port_name(shost
) = be64_to_cpu(nsp
->fl_wwpn
);
478 fc_host_node_name(shost
) = be64_to_cpu(nsp
->fl_wwnn
);
479 fc_host_supported_classes(shost
) = FC_COS_CLASS2
| FC_COS_CLASS3
;
481 adapter
->timer_ticks
= bottom
->timer_interval
& ZFCP_FSF_TIMER_INT_MASK
;
482 adapter
->stat_read_buf_num
= max(bottom
->status_read_buf_num
,
483 (u16
)FSF_STATUS_READS_RECOM
);
485 if (fc_host_permanent_port_name(shost
) == -1)
486 fc_host_permanent_port_name(shost
) = fc_host_port_name(shost
);
488 zfcp_scsi_set_prot(adapter
);
490 /* no error return above here, otherwise must fix call chains */
491 /* do not evaluate invalid fields */
492 if (req
->qtcb
->header
.fsf_status
== FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE
)
495 fc_host_port_id(shost
) = ntoh24(bottom
->s_id
);
496 fc_host_speed(shost
) =
497 zfcp_fsf_convert_portspeed(bottom
->fc_link_speed
);
499 adapter
->hydra_version
= bottom
->adapter_type
;
501 switch (bottom
->fc_topology
) {
503 adapter
->peer_d_id
= ntoh24(bottom
->peer_d_id
);
504 adapter
->peer_wwpn
= be64_to_cpu(plogi
->fl_wwpn
);
505 adapter
->peer_wwnn
= be64_to_cpu(plogi
->fl_wwnn
);
506 fc_host_port_type(shost
) = FC_PORTTYPE_PTP
;
508 case FSF_TOPO_FABRIC
:
509 if (bottom
->connection_features
& FSF_FEATURE_NPIV_MODE
)
510 fc_host_port_type(shost
) = FC_PORTTYPE_NPIV
;
512 fc_host_port_type(shost
) = FC_PORTTYPE_NPORT
;
515 fc_host_port_type(shost
) = FC_PORTTYPE_NLPORT
;
518 dev_err(&adapter
->ccw_device
->dev
,
519 "Unknown or unsupported arbitrated loop "
520 "fibre channel topology detected\n");
521 zfcp_erp_adapter_shutdown(adapter
, 0, "fsece_1");
528 static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req
*req
)
530 struct zfcp_adapter
*adapter
= req
->adapter
;
531 struct fsf_qtcb
*qtcb
= req
->qtcb
;
532 struct fsf_qtcb_bottom_config
*bottom
= &qtcb
->bottom
.config
;
533 struct Scsi_Host
*shost
= adapter
->scsi_host
;
535 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
538 adapter
->fsf_lic_version
= bottom
->lic_version
;
539 adapter
->adapter_features
= bottom
->adapter_features
;
540 adapter
->connection_features
= bottom
->connection_features
;
541 adapter
->peer_wwpn
= 0;
542 adapter
->peer_wwnn
= 0;
543 adapter
->peer_d_id
= 0;
545 switch (qtcb
->header
.fsf_status
) {
547 if (zfcp_fsf_exchange_config_evaluate(req
))
550 if (bottom
->max_qtcb_size
< sizeof(struct fsf_qtcb
)) {
551 dev_err(&adapter
->ccw_device
->dev
,
552 "FCP adapter maximum QTCB size (%d bytes) "
554 bottom
->max_qtcb_size
);
555 zfcp_erp_adapter_shutdown(adapter
, 0, "fsecdh1");
558 atomic_or(ZFCP_STATUS_ADAPTER_XCONFIG_OK
,
561 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE
:
562 fc_host_node_name(shost
) = 0;
563 fc_host_port_name(shost
) = 0;
564 fc_host_port_id(shost
) = 0;
565 fc_host_speed(shost
) = FC_PORTSPEED_UNKNOWN
;
566 fc_host_port_type(shost
) = FC_PORTTYPE_UNKNOWN
;
567 adapter
->hydra_version
= 0;
569 /* avoids adapter shutdown to be able to recognize
570 * events such as LINK UP */
571 atomic_or(ZFCP_STATUS_ADAPTER_XCONFIG_OK
,
573 zfcp_fsf_link_down_info_eval(req
,
574 &qtcb
->header
.fsf_status_qual
.link_down_info
);
575 if (zfcp_fsf_exchange_config_evaluate(req
))
579 zfcp_erp_adapter_shutdown(adapter
, 0, "fsecdh3");
583 if (adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
) {
584 adapter
->hardware_version
= bottom
->hardware_version
;
585 memcpy(fc_host_serial_number(shost
), bottom
->serial_number
,
586 min(FC_SERIAL_NUMBER_SIZE
, 17));
587 EBCASC(fc_host_serial_number(shost
),
588 min(FC_SERIAL_NUMBER_SIZE
, 17));
591 if (FSF_QTCB_CURRENT_VERSION
< bottom
->low_qtcb_version
) {
592 dev_err(&adapter
->ccw_device
->dev
,
593 "The FCP adapter only supports newer "
594 "control block versions\n");
595 zfcp_erp_adapter_shutdown(adapter
, 0, "fsecdh4");
598 if (FSF_QTCB_CURRENT_VERSION
> bottom
->high_qtcb_version
) {
599 dev_err(&adapter
->ccw_device
->dev
,
600 "The FCP adapter only supports older "
601 "control block versions\n");
602 zfcp_erp_adapter_shutdown(adapter
, 0, "fsecdh5");
606 static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req
*req
)
608 struct zfcp_adapter
*adapter
= req
->adapter
;
609 struct fsf_qtcb_bottom_port
*bottom
= &req
->qtcb
->bottom
.port
;
610 struct Scsi_Host
*shost
= adapter
->scsi_host
;
613 memcpy(req
->data
, bottom
, sizeof(*bottom
));
615 if (adapter
->connection_features
& FSF_FEATURE_NPIV_MODE
) {
616 fc_host_permanent_port_name(shost
) = bottom
->wwpn
;
618 fc_host_permanent_port_name(shost
) = fc_host_port_name(shost
);
619 fc_host_maxframe_size(shost
) = bottom
->maximum_frame_size
;
620 fc_host_supported_speeds(shost
) =
621 zfcp_fsf_convert_portspeed(bottom
->supported_speed
);
622 memcpy(fc_host_supported_fc4s(shost
), bottom
->supported_fc4_types
,
624 memcpy(fc_host_active_fc4s(shost
), bottom
->active_fc4_types
,
628 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req
*req
)
630 struct fsf_qtcb
*qtcb
= req
->qtcb
;
632 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
635 switch (qtcb
->header
.fsf_status
) {
637 zfcp_fsf_exchange_port_evaluate(req
);
639 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE
:
640 zfcp_fsf_exchange_port_evaluate(req
);
641 zfcp_fsf_link_down_info_eval(req
,
642 &qtcb
->header
.fsf_status_qual
.link_down_info
);
647 static struct zfcp_fsf_req
*zfcp_fsf_alloc(mempool_t
*pool
)
649 struct zfcp_fsf_req
*req
;
652 req
= mempool_alloc(pool
, GFP_ATOMIC
);
654 req
= kmalloc(sizeof(*req
), GFP_ATOMIC
);
659 memset(req
, 0, sizeof(*req
));
664 static struct fsf_qtcb
*zfcp_qtcb_alloc(mempool_t
*pool
)
666 struct fsf_qtcb
*qtcb
;
669 qtcb
= mempool_alloc(pool
, GFP_ATOMIC
);
671 qtcb
= kmem_cache_alloc(zfcp_fsf_qtcb_cache
, GFP_ATOMIC
);
676 memset(qtcb
, 0, sizeof(*qtcb
));
680 static struct zfcp_fsf_req
*zfcp_fsf_req_create(struct zfcp_qdio
*qdio
,
681 u32 fsf_cmd
, u8 sbtype
,
684 struct zfcp_adapter
*adapter
= qdio
->adapter
;
685 struct zfcp_fsf_req
*req
= zfcp_fsf_alloc(pool
);
688 return ERR_PTR(-ENOMEM
);
690 if (adapter
->req_no
== 0)
693 INIT_LIST_HEAD(&req
->list
);
694 init_timer(&req
->timer
);
695 init_completion(&req
->completion
);
697 req
->adapter
= adapter
;
698 req
->fsf_command
= fsf_cmd
;
699 req
->req_id
= adapter
->req_no
;
701 if (likely(fsf_cmd
!= FSF_QTCB_UNSOLICITED_STATUS
)) {
703 req
->qtcb
= zfcp_qtcb_alloc(adapter
->pool
.qtcb_pool
);
705 req
->qtcb
= zfcp_qtcb_alloc(NULL
);
707 if (unlikely(!req
->qtcb
)) {
708 zfcp_fsf_req_free(req
);
709 return ERR_PTR(-ENOMEM
);
712 req
->seq_no
= adapter
->fsf_req_seq_no
;
713 req
->qtcb
->prefix
.req_seq_no
= adapter
->fsf_req_seq_no
;
714 req
->qtcb
->prefix
.req_id
= req
->req_id
;
715 req
->qtcb
->prefix
.ulp_info
= 26;
716 req
->qtcb
->prefix
.qtcb_type
= fsf_qtcb_type
[req
->fsf_command
];
717 req
->qtcb
->prefix
.qtcb_version
= FSF_QTCB_CURRENT_VERSION
;
718 req
->qtcb
->header
.req_handle
= req
->req_id
;
719 req
->qtcb
->header
.fsf_command
= req
->fsf_command
;
722 zfcp_qdio_req_init(adapter
->qdio
, &req
->qdio_req
, req
->req_id
, sbtype
,
723 req
->qtcb
, sizeof(struct fsf_qtcb
));
728 static int zfcp_fsf_req_send(struct zfcp_fsf_req
*req
)
730 struct zfcp_adapter
*adapter
= req
->adapter
;
731 struct zfcp_qdio
*qdio
= adapter
->qdio
;
732 int with_qtcb
= (req
->qtcb
!= NULL
);
733 int req_id
= req
->req_id
;
735 zfcp_reqlist_add(adapter
->req_list
, req
);
737 req
->qdio_req
.qdio_outb_usage
= atomic_read(&qdio
->req_q_free
);
738 req
->issued
= get_tod_clock();
739 if (zfcp_qdio_send(qdio
, &req
->qdio_req
)) {
740 del_timer(&req
->timer
);
741 /* lookup request again, list might have changed */
742 zfcp_reqlist_find_rm(adapter
->req_list
, req_id
);
743 zfcp_erp_adapter_reopen(adapter
, 0, "fsrs__1");
747 /* Don't increase for unsolicited status */
749 adapter
->fsf_req_seq_no
++;
756 * zfcp_fsf_status_read - send status read request
757 * @adapter: pointer to struct zfcp_adapter
758 * @req_flags: request flags
759 * Returns: 0 on success, ERROR otherwise
761 int zfcp_fsf_status_read(struct zfcp_qdio
*qdio
)
763 struct zfcp_adapter
*adapter
= qdio
->adapter
;
764 struct zfcp_fsf_req
*req
;
765 struct fsf_status_read_buffer
*sr_buf
;
769 spin_lock_irq(&qdio
->req_q_lock
);
770 if (zfcp_qdio_sbal_get(qdio
))
773 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_UNSOLICITED_STATUS
,
774 SBAL_SFLAGS0_TYPE_STATUS
,
775 adapter
->pool
.status_read_req
);
777 retval
= PTR_ERR(req
);
781 page
= mempool_alloc(adapter
->pool
.sr_data
, GFP_ATOMIC
);
786 sr_buf
= page_address(page
);
787 memset(sr_buf
, 0, sizeof(*sr_buf
));
790 zfcp_qdio_fill_next(qdio
, &req
->qdio_req
, sr_buf
, sizeof(*sr_buf
));
791 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
793 retval
= zfcp_fsf_req_send(req
);
795 goto failed_req_send
;
801 mempool_free(virt_to_page(sr_buf
), adapter
->pool
.sr_data
);
803 zfcp_dbf_hba_fsf_uss("fssr__1", req
);
804 zfcp_fsf_req_free(req
);
806 spin_unlock_irq(&qdio
->req_q_lock
);
810 static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req
*req
)
812 struct scsi_device
*sdev
= req
->data
;
813 struct zfcp_scsi_dev
*zfcp_sdev
;
814 union fsf_status_qual
*fsq
= &req
->qtcb
->header
.fsf_status_qual
;
816 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
819 zfcp_sdev
= sdev_to_zfcp(sdev
);
821 switch (req
->qtcb
->header
.fsf_status
) {
822 case FSF_PORT_HANDLE_NOT_VALID
:
823 if (fsq
->word
[0] == fsq
->word
[1]) {
824 zfcp_erp_adapter_reopen(zfcp_sdev
->port
->adapter
, 0,
826 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
829 case FSF_LUN_HANDLE_NOT_VALID
:
830 if (fsq
->word
[0] == fsq
->word
[1]) {
831 zfcp_erp_port_reopen(zfcp_sdev
->port
, 0, "fsafch2");
832 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
835 case FSF_FCP_COMMAND_DOES_NOT_EXIST
:
836 req
->status
|= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED
;
839 zfcp_erp_set_port_status(zfcp_sdev
->port
,
840 ZFCP_STATUS_COMMON_ACCESS_BOXED
);
841 zfcp_erp_port_reopen(zfcp_sdev
->port
,
842 ZFCP_STATUS_COMMON_ERP_FAILED
, "fsafch3");
843 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
846 zfcp_erp_set_lun_status(sdev
, ZFCP_STATUS_COMMON_ACCESS_BOXED
);
847 zfcp_erp_lun_reopen(sdev
, ZFCP_STATUS_COMMON_ERP_FAILED
,
849 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
851 case FSF_ADAPTER_STATUS_AVAILABLE
:
852 switch (fsq
->word
[0]) {
853 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
854 zfcp_fc_test_link(zfcp_sdev
->port
);
856 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
857 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
862 req
->status
|= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED
;
868 * zfcp_fsf_abort_fcp_cmnd - abort running SCSI command
869 * @scmnd: The SCSI command to abort
870 * Returns: pointer to struct zfcp_fsf_req
873 struct zfcp_fsf_req
*zfcp_fsf_abort_fcp_cmnd(struct scsi_cmnd
*scmnd
)
875 struct zfcp_fsf_req
*req
= NULL
;
876 struct scsi_device
*sdev
= scmnd
->device
;
877 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
878 struct zfcp_qdio
*qdio
= zfcp_sdev
->port
->adapter
->qdio
;
879 unsigned long old_req_id
= (unsigned long) scmnd
->host_scribble
;
881 spin_lock_irq(&qdio
->req_q_lock
);
882 if (zfcp_qdio_sbal_get(qdio
))
884 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_ABORT_FCP_CMND
,
885 SBAL_SFLAGS0_TYPE_READ
,
886 qdio
->adapter
->pool
.scsi_abort
);
892 if (unlikely(!(atomic_read(&zfcp_sdev
->status
) &
893 ZFCP_STATUS_COMMON_UNBLOCKED
)))
896 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
899 req
->handler
= zfcp_fsf_abort_fcp_command_handler
;
900 req
->qtcb
->header
.lun_handle
= zfcp_sdev
->lun_handle
;
901 req
->qtcb
->header
.port_handle
= zfcp_sdev
->port
->handle
;
902 req
->qtcb
->bottom
.support
.req_handle
= (u64
) old_req_id
;
904 zfcp_fsf_start_timer(req
, ZFCP_SCSI_ER_TIMEOUT
);
905 if (!zfcp_fsf_req_send(req
))
909 zfcp_fsf_req_free(req
);
912 spin_unlock_irq(&qdio
->req_q_lock
);
916 static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req
*req
)
918 struct zfcp_adapter
*adapter
= req
->adapter
;
919 struct zfcp_fsf_ct_els
*ct
= req
->data
;
920 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
922 ct
->status
= -EINVAL
;
924 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
927 switch (header
->fsf_status
) {
930 zfcp_dbf_san_res("fsscth2", req
);
932 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
933 zfcp_fsf_class_not_supp(req
);
935 case FSF_ADAPTER_STATUS_AVAILABLE
:
936 switch (header
->fsf_status_qual
.word
[0]){
937 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
938 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
939 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
944 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
946 case FSF_PORT_HANDLE_NOT_VALID
:
947 zfcp_erp_adapter_reopen(adapter
, 0, "fsscth1");
949 case FSF_GENERIC_COMMAND_REJECTED
:
950 case FSF_PAYLOAD_SIZE_MISMATCH
:
951 case FSF_REQUEST_SIZE_TOO_LARGE
:
952 case FSF_RESPONSE_SIZE_TOO_LARGE
:
953 case FSF_SBAL_MISMATCH
:
954 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
960 ct
->handler(ct
->handler_data
);
963 static void zfcp_fsf_setup_ct_els_unchained(struct zfcp_qdio
*qdio
,
964 struct zfcp_qdio_req
*q_req
,
965 struct scatterlist
*sg_req
,
966 struct scatterlist
*sg_resp
)
968 zfcp_qdio_fill_next(qdio
, q_req
, sg_virt(sg_req
), sg_req
->length
);
969 zfcp_qdio_fill_next(qdio
, q_req
, sg_virt(sg_resp
), sg_resp
->length
);
970 zfcp_qdio_set_sbale_last(qdio
, q_req
);
973 static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req
*req
,
974 struct scatterlist
*sg_req
,
975 struct scatterlist
*sg_resp
)
977 struct zfcp_adapter
*adapter
= req
->adapter
;
978 struct zfcp_qdio
*qdio
= adapter
->qdio
;
979 struct fsf_qtcb
*qtcb
= req
->qtcb
;
980 u32 feat
= adapter
->adapter_features
;
982 if (zfcp_adapter_multi_buffer_active(adapter
)) {
983 if (zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
, sg_req
))
985 qtcb
->bottom
.support
.req_buf_length
=
986 zfcp_qdio_real_bytes(sg_req
);
987 if (zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
, sg_resp
))
989 qtcb
->bottom
.support
.resp_buf_length
=
990 zfcp_qdio_real_bytes(sg_resp
);
992 zfcp_qdio_set_data_div(qdio
, &req
->qdio_req
, sg_nents(sg_req
));
993 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
994 zfcp_qdio_set_scount(qdio
, &req
->qdio_req
);
998 /* use single, unchained SBAL if it can hold the request */
999 if (zfcp_qdio_sg_one_sbale(sg_req
) && zfcp_qdio_sg_one_sbale(sg_resp
)) {
1000 zfcp_fsf_setup_ct_els_unchained(qdio
, &req
->qdio_req
,
1005 if (!(feat
& FSF_FEATURE_ELS_CT_CHAINED_SBALS
))
1008 if (zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
, sg_req
))
1011 qtcb
->bottom
.support
.req_buf_length
= zfcp_qdio_real_bytes(sg_req
);
1013 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1014 zfcp_qdio_skip_to_last_sbale(qdio
, &req
->qdio_req
);
1016 if (zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
, sg_resp
))
1019 qtcb
->bottom
.support
.resp_buf_length
= zfcp_qdio_real_bytes(sg_resp
);
1021 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1026 static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req
*req
,
1027 struct scatterlist
*sg_req
,
1028 struct scatterlist
*sg_resp
,
1029 unsigned int timeout
)
1033 ret
= zfcp_fsf_setup_ct_els_sbals(req
, sg_req
, sg_resp
);
1037 /* common settings for ct/gs and els requests */
1039 timeout
= 255; /* max value accepted by hardware */
1040 req
->qtcb
->bottom
.support
.service_class
= FSF_CLASS_3
;
1041 req
->qtcb
->bottom
.support
.timeout
= timeout
;
1042 zfcp_fsf_start_timer(req
, (timeout
+ 10) * HZ
);
1048 * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
1049 * @ct: pointer to struct zfcp_send_ct with data for request
1050 * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
1052 int zfcp_fsf_send_ct(struct zfcp_fc_wka_port
*wka_port
,
1053 struct zfcp_fsf_ct_els
*ct
, mempool_t
*pool
,
1054 unsigned int timeout
)
1056 struct zfcp_qdio
*qdio
= wka_port
->adapter
->qdio
;
1057 struct zfcp_fsf_req
*req
;
1060 spin_lock_irq(&qdio
->req_q_lock
);
1061 if (zfcp_qdio_sbal_get(qdio
))
1064 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_SEND_GENERIC
,
1065 SBAL_SFLAGS0_TYPE_WRITE_READ
, pool
);
1072 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1073 ret
= zfcp_fsf_setup_ct_els(req
, ct
->req
, ct
->resp
, timeout
);
1077 req
->handler
= zfcp_fsf_send_ct_handler
;
1078 req
->qtcb
->header
.port_handle
= wka_port
->handle
;
1079 ct
->d_id
= wka_port
->d_id
;
1082 zfcp_dbf_san_req("fssct_1", req
, wka_port
->d_id
);
1084 ret
= zfcp_fsf_req_send(req
);
1091 zfcp_fsf_req_free(req
);
1093 spin_unlock_irq(&qdio
->req_q_lock
);
1097 static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req
*req
)
1099 struct zfcp_fsf_ct_els
*send_els
= req
->data
;
1100 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1102 send_els
->status
= -EINVAL
;
1104 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1105 goto skip_fsfstatus
;
1107 switch (header
->fsf_status
) {
1109 send_els
->status
= 0;
1110 zfcp_dbf_san_res("fsselh1", req
);
1112 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
1113 zfcp_fsf_class_not_supp(req
);
1115 case FSF_ADAPTER_STATUS_AVAILABLE
:
1116 switch (header
->fsf_status_qual
.word
[0]){
1117 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1118 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1119 case FSF_SQ_RETRY_IF_POSSIBLE
:
1120 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1124 case FSF_ELS_COMMAND_REJECTED
:
1125 case FSF_PAYLOAD_SIZE_MISMATCH
:
1126 case FSF_REQUEST_SIZE_TOO_LARGE
:
1127 case FSF_RESPONSE_SIZE_TOO_LARGE
:
1129 case FSF_SBAL_MISMATCH
:
1130 /* should never occur, avoided in zfcp_fsf_send_els */
1133 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1137 if (send_els
->handler
)
1138 send_els
->handler(send_els
->handler_data
);
1142 * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
1143 * @els: pointer to struct zfcp_send_els with data for the command
1145 int zfcp_fsf_send_els(struct zfcp_adapter
*adapter
, u32 d_id
,
1146 struct zfcp_fsf_ct_els
*els
, unsigned int timeout
)
1148 struct zfcp_fsf_req
*req
;
1149 struct zfcp_qdio
*qdio
= adapter
->qdio
;
1152 spin_lock_irq(&qdio
->req_q_lock
);
1153 if (zfcp_qdio_sbal_get(qdio
))
1156 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_SEND_ELS
,
1157 SBAL_SFLAGS0_TYPE_WRITE_READ
, NULL
);
1164 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1166 if (!zfcp_adapter_multi_buffer_active(adapter
))
1167 zfcp_qdio_sbal_limit(qdio
, &req
->qdio_req
, 2);
1169 ret
= zfcp_fsf_setup_ct_els(req
, els
->req
, els
->resp
, timeout
);
1174 hton24(req
->qtcb
->bottom
.support
.d_id
, d_id
);
1175 req
->handler
= zfcp_fsf_send_els_handler
;
1179 zfcp_dbf_san_req("fssels1", req
, d_id
);
1181 ret
= zfcp_fsf_req_send(req
);
1188 zfcp_fsf_req_free(req
);
1190 spin_unlock_irq(&qdio
->req_q_lock
);
1194 int zfcp_fsf_exchange_config_data(struct zfcp_erp_action
*erp_action
)
1196 struct zfcp_fsf_req
*req
;
1197 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1200 spin_lock_irq(&qdio
->req_q_lock
);
1201 if (zfcp_qdio_sbal_get(qdio
))
1204 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_EXCHANGE_CONFIG_DATA
,
1205 SBAL_SFLAGS0_TYPE_READ
,
1206 qdio
->adapter
->pool
.erp_req
);
1209 retval
= PTR_ERR(req
);
1213 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1214 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1216 req
->qtcb
->bottom
.config
.feature_selection
=
1217 FSF_FEATURE_NOTIFICATION_LOST
|
1218 FSF_FEATURE_UPDATE_ALERT
;
1219 req
->erp_action
= erp_action
;
1220 req
->handler
= zfcp_fsf_exchange_config_data_handler
;
1221 erp_action
->fsf_req_id
= req
->req_id
;
1223 zfcp_fsf_start_erp_timer(req
);
1224 retval
= zfcp_fsf_req_send(req
);
1226 zfcp_fsf_req_free(req
);
1227 erp_action
->fsf_req_id
= 0;
1230 spin_unlock_irq(&qdio
->req_q_lock
);
1234 int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio
*qdio
,
1235 struct fsf_qtcb_bottom_config
*data
)
1237 struct zfcp_fsf_req
*req
= NULL
;
1240 spin_lock_irq(&qdio
->req_q_lock
);
1241 if (zfcp_qdio_sbal_get(qdio
))
1244 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_EXCHANGE_CONFIG_DATA
,
1245 SBAL_SFLAGS0_TYPE_READ
, NULL
);
1248 retval
= PTR_ERR(req
);
1252 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1253 req
->handler
= zfcp_fsf_exchange_config_data_handler
;
1255 req
->qtcb
->bottom
.config
.feature_selection
=
1256 FSF_FEATURE_NOTIFICATION_LOST
|
1257 FSF_FEATURE_UPDATE_ALERT
;
1262 zfcp_fsf_start_timer(req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1263 retval
= zfcp_fsf_req_send(req
);
1264 spin_unlock_irq(&qdio
->req_q_lock
);
1266 wait_for_completion(&req
->completion
);
1268 zfcp_fsf_req_free(req
);
1272 spin_unlock_irq(&qdio
->req_q_lock
);
1277 * zfcp_fsf_exchange_port_data - request information about local port
1278 * @erp_action: ERP action for the adapter for which port data is requested
1279 * Returns: 0 on success, error otherwise
1281 int zfcp_fsf_exchange_port_data(struct zfcp_erp_action
*erp_action
)
1283 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1284 struct zfcp_fsf_req
*req
;
1287 if (!(qdio
->adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
))
1290 spin_lock_irq(&qdio
->req_q_lock
);
1291 if (zfcp_qdio_sbal_get(qdio
))
1294 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_EXCHANGE_PORT_DATA
,
1295 SBAL_SFLAGS0_TYPE_READ
,
1296 qdio
->adapter
->pool
.erp_req
);
1299 retval
= PTR_ERR(req
);
1303 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1304 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1306 req
->handler
= zfcp_fsf_exchange_port_data_handler
;
1307 req
->erp_action
= erp_action
;
1308 erp_action
->fsf_req_id
= req
->req_id
;
1310 zfcp_fsf_start_erp_timer(req
);
1311 retval
= zfcp_fsf_req_send(req
);
1313 zfcp_fsf_req_free(req
);
1314 erp_action
->fsf_req_id
= 0;
1317 spin_unlock_irq(&qdio
->req_q_lock
);
1322 * zfcp_fsf_exchange_port_data_sync - request information about local port
1323 * @qdio: pointer to struct zfcp_qdio
1324 * @data: pointer to struct fsf_qtcb_bottom_port
1325 * Returns: 0 on success, error otherwise
1327 int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio
*qdio
,
1328 struct fsf_qtcb_bottom_port
*data
)
1330 struct zfcp_fsf_req
*req
= NULL
;
1333 if (!(qdio
->adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
))
1336 spin_lock_irq(&qdio
->req_q_lock
);
1337 if (zfcp_qdio_sbal_get(qdio
))
1340 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_EXCHANGE_PORT_DATA
,
1341 SBAL_SFLAGS0_TYPE_READ
, NULL
);
1344 retval
= PTR_ERR(req
);
1351 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1353 req
->handler
= zfcp_fsf_exchange_port_data_handler
;
1354 zfcp_fsf_start_timer(req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1355 retval
= zfcp_fsf_req_send(req
);
1356 spin_unlock_irq(&qdio
->req_q_lock
);
1359 wait_for_completion(&req
->completion
);
1361 zfcp_fsf_req_free(req
);
1366 spin_unlock_irq(&qdio
->req_q_lock
);
1370 static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req
*req
)
1372 struct zfcp_port
*port
= req
->data
;
1373 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1374 struct fc_els_flogi
*plogi
;
1376 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1379 switch (header
->fsf_status
) {
1380 case FSF_PORT_ALREADY_OPEN
:
1382 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED
:
1383 dev_warn(&req
->adapter
->ccw_device
->dev
,
1384 "Not enough FCP adapter resources to open "
1385 "remote port 0x%016Lx\n",
1386 (unsigned long long)port
->wwpn
);
1387 zfcp_erp_set_port_status(port
,
1388 ZFCP_STATUS_COMMON_ERP_FAILED
);
1389 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1391 case FSF_ADAPTER_STATUS_AVAILABLE
:
1392 switch (header
->fsf_status_qual
.word
[0]) {
1393 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1394 /* no zfcp_fc_test_link() with failed open port */
1396 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1397 case FSF_SQ_NO_RETRY_POSSIBLE
:
1398 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1403 port
->handle
= header
->port_handle
;
1404 atomic_or(ZFCP_STATUS_COMMON_OPEN
|
1405 ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
1406 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_BOXED
,
1408 /* check whether D_ID has changed during open */
1410 * FIXME: This check is not airtight, as the FCP channel does
1411 * not monitor closures of target port connections caused on
1412 * the remote side. Thus, they might miss out on invalidating
1413 * locally cached WWPNs (and other N_Port parameters) of gone
1414 * target ports. So, our heroic attempt to make things safe
1415 * could be undermined by 'open port' response data tagged with
1416 * obsolete WWPNs. Another reason to monitor potential
1417 * connection closures ourself at least (by interpreting
1418 * incoming ELS' and unsolicited status). It just crosses my
1419 * mind that one should be able to cross-check by means of
1420 * another GID_PN straight after a port has been opened.
1421 * Alternately, an ADISC/PDISC ELS should suffice, as well.
1423 plogi
= (struct fc_els_flogi
*) req
->qtcb
->bottom
.support
.els
;
1424 if (req
->qtcb
->bottom
.support
.els1_length
>=
1426 zfcp_fc_plogi_evaluate(port
, plogi
);
1428 case FSF_UNKNOWN_OP_SUBTYPE
:
1429 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1434 put_device(&port
->dev
);
1438 * zfcp_fsf_open_port - create and send open port request
1439 * @erp_action: pointer to struct zfcp_erp_action
1440 * Returns: 0 on success, error otherwise
1442 int zfcp_fsf_open_port(struct zfcp_erp_action
*erp_action
)
1444 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1445 struct zfcp_port
*port
= erp_action
->port
;
1446 struct zfcp_fsf_req
*req
;
1449 spin_lock_irq(&qdio
->req_q_lock
);
1450 if (zfcp_qdio_sbal_get(qdio
))
1453 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_OPEN_PORT_WITH_DID
,
1454 SBAL_SFLAGS0_TYPE_READ
,
1455 qdio
->adapter
->pool
.erp_req
);
1458 retval
= PTR_ERR(req
);
1462 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1463 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1465 req
->handler
= zfcp_fsf_open_port_handler
;
1466 hton24(req
->qtcb
->bottom
.support
.d_id
, port
->d_id
);
1468 req
->erp_action
= erp_action
;
1469 erp_action
->fsf_req_id
= req
->req_id
;
1470 get_device(&port
->dev
);
1472 zfcp_fsf_start_erp_timer(req
);
1473 retval
= zfcp_fsf_req_send(req
);
1475 zfcp_fsf_req_free(req
);
1476 erp_action
->fsf_req_id
= 0;
1477 put_device(&port
->dev
);
1480 spin_unlock_irq(&qdio
->req_q_lock
);
1484 static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req
*req
)
1486 struct zfcp_port
*port
= req
->data
;
1488 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1491 switch (req
->qtcb
->header
.fsf_status
) {
1492 case FSF_PORT_HANDLE_NOT_VALID
:
1493 zfcp_erp_adapter_reopen(port
->adapter
, 0, "fscph_1");
1494 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1496 case FSF_ADAPTER_STATUS_AVAILABLE
:
1499 zfcp_erp_clear_port_status(port
, ZFCP_STATUS_COMMON_OPEN
);
1505 * zfcp_fsf_close_port - create and send close port request
1506 * @erp_action: pointer to struct zfcp_erp_action
1507 * Returns: 0 on success, error otherwise
1509 int zfcp_fsf_close_port(struct zfcp_erp_action
*erp_action
)
1511 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1512 struct zfcp_fsf_req
*req
;
1515 spin_lock_irq(&qdio
->req_q_lock
);
1516 if (zfcp_qdio_sbal_get(qdio
))
1519 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_CLOSE_PORT
,
1520 SBAL_SFLAGS0_TYPE_READ
,
1521 qdio
->adapter
->pool
.erp_req
);
1524 retval
= PTR_ERR(req
);
1528 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1529 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1531 req
->handler
= zfcp_fsf_close_port_handler
;
1532 req
->data
= erp_action
->port
;
1533 req
->erp_action
= erp_action
;
1534 req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
1535 erp_action
->fsf_req_id
= req
->req_id
;
1537 zfcp_fsf_start_erp_timer(req
);
1538 retval
= zfcp_fsf_req_send(req
);
1540 zfcp_fsf_req_free(req
);
1541 erp_action
->fsf_req_id
= 0;
1544 spin_unlock_irq(&qdio
->req_q_lock
);
1548 static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req
*req
)
1550 struct zfcp_fc_wka_port
*wka_port
= req
->data
;
1551 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1553 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
1554 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
1558 switch (header
->fsf_status
) {
1559 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED
:
1560 dev_warn(&req
->adapter
->ccw_device
->dev
,
1561 "Opening WKA port 0x%x failed\n", wka_port
->d_id
);
1563 case FSF_ADAPTER_STATUS_AVAILABLE
:
1564 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1565 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
1568 wka_port
->handle
= header
->port_handle
;
1570 case FSF_PORT_ALREADY_OPEN
:
1571 wka_port
->status
= ZFCP_FC_WKA_PORT_ONLINE
;
1574 wake_up(&wka_port
->completion_wq
);
1578 * zfcp_fsf_open_wka_port - create and send open wka-port request
1579 * @wka_port: pointer to struct zfcp_fc_wka_port
1580 * Returns: 0 on success, error otherwise
1582 int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port
*wka_port
)
1584 struct zfcp_qdio
*qdio
= wka_port
->adapter
->qdio
;
1585 struct zfcp_fsf_req
*req
;
1588 spin_lock_irq(&qdio
->req_q_lock
);
1589 if (zfcp_qdio_sbal_get(qdio
))
1592 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_OPEN_PORT_WITH_DID
,
1593 SBAL_SFLAGS0_TYPE_READ
,
1594 qdio
->adapter
->pool
.erp_req
);
1597 retval
= PTR_ERR(req
);
1601 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1602 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1604 req
->handler
= zfcp_fsf_open_wka_port_handler
;
1605 hton24(req
->qtcb
->bottom
.support
.d_id
, wka_port
->d_id
);
1606 req
->data
= wka_port
;
1608 zfcp_fsf_start_timer(req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1609 retval
= zfcp_fsf_req_send(req
);
1611 zfcp_fsf_req_free(req
);
1613 spin_unlock_irq(&qdio
->req_q_lock
);
1615 zfcp_dbf_rec_run_wka("fsowp_1", wka_port
, req
->req_id
);
1619 static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req
*req
)
1621 struct zfcp_fc_wka_port
*wka_port
= req
->data
;
1623 if (req
->qtcb
->header
.fsf_status
== FSF_PORT_HANDLE_NOT_VALID
) {
1624 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1625 zfcp_erp_adapter_reopen(wka_port
->adapter
, 0, "fscwph1");
1628 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
1629 wake_up(&wka_port
->completion_wq
);
1633 * zfcp_fsf_close_wka_port - create and send close wka port request
1634 * @wka_port: WKA port to open
1635 * Returns: 0 on success, error otherwise
1637 int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port
*wka_port
)
1639 struct zfcp_qdio
*qdio
= wka_port
->adapter
->qdio
;
1640 struct zfcp_fsf_req
*req
;
1643 spin_lock_irq(&qdio
->req_q_lock
);
1644 if (zfcp_qdio_sbal_get(qdio
))
1647 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_CLOSE_PORT
,
1648 SBAL_SFLAGS0_TYPE_READ
,
1649 qdio
->adapter
->pool
.erp_req
);
1652 retval
= PTR_ERR(req
);
1656 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1657 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1659 req
->handler
= zfcp_fsf_close_wka_port_handler
;
1660 req
->data
= wka_port
;
1661 req
->qtcb
->header
.port_handle
= wka_port
->handle
;
1663 zfcp_fsf_start_timer(req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1664 retval
= zfcp_fsf_req_send(req
);
1666 zfcp_fsf_req_free(req
);
1668 spin_unlock_irq(&qdio
->req_q_lock
);
1670 zfcp_dbf_rec_run_wka("fscwp_1", wka_port
, req
->req_id
);
1674 static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req
*req
)
1676 struct zfcp_port
*port
= req
->data
;
1677 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1678 struct scsi_device
*sdev
;
1680 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1683 switch (header
->fsf_status
) {
1684 case FSF_PORT_HANDLE_NOT_VALID
:
1685 zfcp_erp_adapter_reopen(port
->adapter
, 0, "fscpph1");
1686 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1688 case FSF_PORT_BOXED
:
1689 /* can't use generic zfcp_erp_modify_port_status because
1690 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
1691 atomic_andnot(ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
1692 shost_for_each_device(sdev
, port
->adapter
->scsi_host
)
1693 if (sdev_to_zfcp(sdev
)->port
== port
)
1694 atomic_andnot(ZFCP_STATUS_COMMON_OPEN
,
1695 &sdev_to_zfcp(sdev
)->status
);
1696 zfcp_erp_set_port_status(port
, ZFCP_STATUS_COMMON_ACCESS_BOXED
);
1697 zfcp_erp_port_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
1699 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1701 case FSF_ADAPTER_STATUS_AVAILABLE
:
1702 switch (header
->fsf_status_qual
.word
[0]) {
1703 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1705 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1706 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1711 /* can't use generic zfcp_erp_modify_port_status because
1712 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
1714 atomic_andnot(ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
1715 shost_for_each_device(sdev
, port
->adapter
->scsi_host
)
1716 if (sdev_to_zfcp(sdev
)->port
== port
)
1717 atomic_andnot(ZFCP_STATUS_COMMON_OPEN
,
1718 &sdev_to_zfcp(sdev
)->status
);
1724 * zfcp_fsf_close_physical_port - close physical port
1725 * @erp_action: pointer to struct zfcp_erp_action
1726 * Returns: 0 on success
1728 int zfcp_fsf_close_physical_port(struct zfcp_erp_action
*erp_action
)
1730 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1731 struct zfcp_fsf_req
*req
;
1734 spin_lock_irq(&qdio
->req_q_lock
);
1735 if (zfcp_qdio_sbal_get(qdio
))
1738 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_CLOSE_PHYSICAL_PORT
,
1739 SBAL_SFLAGS0_TYPE_READ
,
1740 qdio
->adapter
->pool
.erp_req
);
1743 retval
= PTR_ERR(req
);
1747 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1748 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1750 req
->data
= erp_action
->port
;
1751 req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
1752 req
->erp_action
= erp_action
;
1753 req
->handler
= zfcp_fsf_close_physical_port_handler
;
1754 erp_action
->fsf_req_id
= req
->req_id
;
1756 zfcp_fsf_start_erp_timer(req
);
1757 retval
= zfcp_fsf_req_send(req
);
1759 zfcp_fsf_req_free(req
);
1760 erp_action
->fsf_req_id
= 0;
1763 spin_unlock_irq(&qdio
->req_q_lock
);
1767 static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req
*req
)
1769 struct zfcp_adapter
*adapter
= req
->adapter
;
1770 struct scsi_device
*sdev
= req
->data
;
1771 struct zfcp_scsi_dev
*zfcp_sdev
;
1772 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1773 union fsf_status_qual
*qual
= &header
->fsf_status_qual
;
1775 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1778 zfcp_sdev
= sdev_to_zfcp(sdev
);
1780 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED
|
1781 ZFCP_STATUS_COMMON_ACCESS_BOXED
,
1782 &zfcp_sdev
->status
);
1784 switch (header
->fsf_status
) {
1786 case FSF_PORT_HANDLE_NOT_VALID
:
1787 zfcp_erp_adapter_reopen(adapter
, 0, "fsouh_1");
1789 case FSF_LUN_ALREADY_OPEN
:
1791 case FSF_PORT_BOXED
:
1792 zfcp_erp_set_port_status(zfcp_sdev
->port
,
1793 ZFCP_STATUS_COMMON_ACCESS_BOXED
);
1794 zfcp_erp_port_reopen(zfcp_sdev
->port
,
1795 ZFCP_STATUS_COMMON_ERP_FAILED
, "fsouh_2");
1796 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1798 case FSF_LUN_SHARING_VIOLATION
:
1800 dev_warn(&zfcp_sdev
->port
->adapter
->ccw_device
->dev
,
1801 "LUN 0x%Lx on port 0x%Lx is already in "
1802 "use by CSS%d, MIF Image ID %x\n",
1803 zfcp_scsi_dev_lun(sdev
),
1804 (unsigned long long)zfcp_sdev
->port
->wwpn
,
1805 qual
->fsf_queue_designator
.cssid
,
1806 qual
->fsf_queue_designator
.hla
);
1807 zfcp_erp_set_lun_status(sdev
,
1808 ZFCP_STATUS_COMMON_ERP_FAILED
|
1809 ZFCP_STATUS_COMMON_ACCESS_DENIED
);
1810 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1812 case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED
:
1813 dev_warn(&adapter
->ccw_device
->dev
,
1814 "No handle is available for LUN "
1815 "0x%016Lx on port 0x%016Lx\n",
1816 (unsigned long long)zfcp_scsi_dev_lun(sdev
),
1817 (unsigned long long)zfcp_sdev
->port
->wwpn
);
1818 zfcp_erp_set_lun_status(sdev
, ZFCP_STATUS_COMMON_ERP_FAILED
);
1820 case FSF_INVALID_COMMAND_OPTION
:
1821 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1823 case FSF_ADAPTER_STATUS_AVAILABLE
:
1824 switch (header
->fsf_status_qual
.word
[0]) {
1825 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1826 zfcp_fc_test_link(zfcp_sdev
->port
);
1828 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1829 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1835 zfcp_sdev
->lun_handle
= header
->lun_handle
;
1836 atomic_or(ZFCP_STATUS_COMMON_OPEN
, &zfcp_sdev
->status
);
1842 * zfcp_fsf_open_lun - open LUN
1843 * @erp_action: pointer to struct zfcp_erp_action
1844 * Returns: 0 on success, error otherwise
1846 int zfcp_fsf_open_lun(struct zfcp_erp_action
*erp_action
)
1848 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
1849 struct zfcp_qdio
*qdio
= adapter
->qdio
;
1850 struct zfcp_fsf_req
*req
;
1853 spin_lock_irq(&qdio
->req_q_lock
);
1854 if (zfcp_qdio_sbal_get(qdio
))
1857 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_OPEN_LUN
,
1858 SBAL_SFLAGS0_TYPE_READ
,
1859 adapter
->pool
.erp_req
);
1862 retval
= PTR_ERR(req
);
1866 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1867 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1869 req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
1870 req
->qtcb
->bottom
.support
.fcp_lun
= zfcp_scsi_dev_lun(erp_action
->sdev
);
1871 req
->handler
= zfcp_fsf_open_lun_handler
;
1872 req
->data
= erp_action
->sdev
;
1873 req
->erp_action
= erp_action
;
1874 erp_action
->fsf_req_id
= req
->req_id
;
1876 if (!(adapter
->connection_features
& FSF_FEATURE_NPIV_MODE
))
1877 req
->qtcb
->bottom
.support
.option
= FSF_OPEN_LUN_SUPPRESS_BOXING
;
1879 zfcp_fsf_start_erp_timer(req
);
1880 retval
= zfcp_fsf_req_send(req
);
1882 zfcp_fsf_req_free(req
);
1883 erp_action
->fsf_req_id
= 0;
1886 spin_unlock_irq(&qdio
->req_q_lock
);
1890 static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req
*req
)
1892 struct scsi_device
*sdev
= req
->data
;
1893 struct zfcp_scsi_dev
*zfcp_sdev
;
1895 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1898 zfcp_sdev
= sdev_to_zfcp(sdev
);
1900 switch (req
->qtcb
->header
.fsf_status
) {
1901 case FSF_PORT_HANDLE_NOT_VALID
:
1902 zfcp_erp_adapter_reopen(zfcp_sdev
->port
->adapter
, 0, "fscuh_1");
1903 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1905 case FSF_LUN_HANDLE_NOT_VALID
:
1906 zfcp_erp_port_reopen(zfcp_sdev
->port
, 0, "fscuh_2");
1907 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1909 case FSF_PORT_BOXED
:
1910 zfcp_erp_set_port_status(zfcp_sdev
->port
,
1911 ZFCP_STATUS_COMMON_ACCESS_BOXED
);
1912 zfcp_erp_port_reopen(zfcp_sdev
->port
,
1913 ZFCP_STATUS_COMMON_ERP_FAILED
, "fscuh_3");
1914 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1916 case FSF_ADAPTER_STATUS_AVAILABLE
:
1917 switch (req
->qtcb
->header
.fsf_status_qual
.word
[0]) {
1918 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1919 zfcp_fc_test_link(zfcp_sdev
->port
);
1921 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1922 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1927 atomic_andnot(ZFCP_STATUS_COMMON_OPEN
, &zfcp_sdev
->status
);
1933 * zfcp_fsf_close_LUN - close LUN
1934 * @erp_action: pointer to erp_action triggering the "close LUN"
1935 * Returns: 0 on success, error otherwise
1937 int zfcp_fsf_close_lun(struct zfcp_erp_action
*erp_action
)
1939 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1940 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(erp_action
->sdev
);
1941 struct zfcp_fsf_req
*req
;
1944 spin_lock_irq(&qdio
->req_q_lock
);
1945 if (zfcp_qdio_sbal_get(qdio
))
1948 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_CLOSE_LUN
,
1949 SBAL_SFLAGS0_TYPE_READ
,
1950 qdio
->adapter
->pool
.erp_req
);
1953 retval
= PTR_ERR(req
);
1957 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1958 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1960 req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
1961 req
->qtcb
->header
.lun_handle
= zfcp_sdev
->lun_handle
;
1962 req
->handler
= zfcp_fsf_close_lun_handler
;
1963 req
->data
= erp_action
->sdev
;
1964 req
->erp_action
= erp_action
;
1965 erp_action
->fsf_req_id
= req
->req_id
;
1967 zfcp_fsf_start_erp_timer(req
);
1968 retval
= zfcp_fsf_req_send(req
);
1970 zfcp_fsf_req_free(req
);
1971 erp_action
->fsf_req_id
= 0;
1974 spin_unlock_irq(&qdio
->req_q_lock
);
1978 static void zfcp_fsf_update_lat(struct fsf_latency_record
*lat_rec
, u32 lat
)
1980 lat_rec
->sum
+= lat
;
1981 lat_rec
->min
= min(lat_rec
->min
, lat
);
1982 lat_rec
->max
= max(lat_rec
->max
, lat
);
1985 static void zfcp_fsf_req_trace(struct zfcp_fsf_req
*req
, struct scsi_cmnd
*scsi
)
1987 struct fsf_qual_latency_info
*lat_in
;
1988 struct latency_cont
*lat
= NULL
;
1989 struct zfcp_scsi_dev
*zfcp_sdev
;
1990 struct zfcp_blk_drv_data blktrc
;
1991 int ticks
= req
->adapter
->timer_ticks
;
1993 lat_in
= &req
->qtcb
->prefix
.prot_status_qual
.latency_info
;
1996 blktrc
.magic
= ZFCP_BLK_DRV_DATA_MAGIC
;
1997 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1998 blktrc
.flags
|= ZFCP_BLK_REQ_ERROR
;
1999 blktrc
.inb_usage
= 0;
2000 blktrc
.outb_usage
= req
->qdio_req
.qdio_outb_usage
;
2002 if (req
->adapter
->adapter_features
& FSF_FEATURE_MEASUREMENT_DATA
&&
2003 !(req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)) {
2004 zfcp_sdev
= sdev_to_zfcp(scsi
->device
);
2005 blktrc
.flags
|= ZFCP_BLK_LAT_VALID
;
2006 blktrc
.channel_lat
= lat_in
->channel_lat
* ticks
;
2007 blktrc
.fabric_lat
= lat_in
->fabric_lat
* ticks
;
2009 switch (req
->qtcb
->bottom
.io
.data_direction
) {
2010 case FSF_DATADIR_DIF_READ_STRIP
:
2011 case FSF_DATADIR_DIF_READ_CONVERT
:
2012 case FSF_DATADIR_READ
:
2013 lat
= &zfcp_sdev
->latencies
.read
;
2015 case FSF_DATADIR_DIF_WRITE_INSERT
:
2016 case FSF_DATADIR_DIF_WRITE_CONVERT
:
2017 case FSF_DATADIR_WRITE
:
2018 lat
= &zfcp_sdev
->latencies
.write
;
2020 case FSF_DATADIR_CMND
:
2021 lat
= &zfcp_sdev
->latencies
.cmd
;
2026 spin_lock(&zfcp_sdev
->latencies
.lock
);
2027 zfcp_fsf_update_lat(&lat
->channel
, lat_in
->channel_lat
);
2028 zfcp_fsf_update_lat(&lat
->fabric
, lat_in
->fabric_lat
);
2030 spin_unlock(&zfcp_sdev
->latencies
.lock
);
2034 blk_add_driver_data(scsi
->request
->q
, scsi
->request
, &blktrc
,
2038 static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req
*req
)
2040 struct scsi_cmnd
*scmnd
= req
->data
;
2041 struct scsi_device
*sdev
= scmnd
->device
;
2042 struct zfcp_scsi_dev
*zfcp_sdev
;
2043 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
2045 if (unlikely(req
->status
& ZFCP_STATUS_FSFREQ_ERROR
))
2048 zfcp_sdev
= sdev_to_zfcp(sdev
);
2050 switch (header
->fsf_status
) {
2051 case FSF_HANDLE_MISMATCH
:
2052 case FSF_PORT_HANDLE_NOT_VALID
:
2053 zfcp_erp_adapter_reopen(zfcp_sdev
->port
->adapter
, 0, "fssfch1");
2054 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2056 case FSF_FCPLUN_NOT_VALID
:
2057 case FSF_LUN_HANDLE_NOT_VALID
:
2058 zfcp_erp_port_reopen(zfcp_sdev
->port
, 0, "fssfch2");
2059 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2061 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
2062 zfcp_fsf_class_not_supp(req
);
2064 case FSF_DIRECTION_INDICATOR_NOT_VALID
:
2065 dev_err(&req
->adapter
->ccw_device
->dev
,
2066 "Incorrect direction %d, LUN 0x%016Lx on port "
2067 "0x%016Lx closed\n",
2068 req
->qtcb
->bottom
.io
.data_direction
,
2069 (unsigned long long)zfcp_scsi_dev_lun(sdev
),
2070 (unsigned long long)zfcp_sdev
->port
->wwpn
);
2071 zfcp_erp_adapter_shutdown(zfcp_sdev
->port
->adapter
, 0,
2073 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2075 case FSF_CMND_LENGTH_NOT_VALID
:
2076 dev_err(&req
->adapter
->ccw_device
->dev
,
2077 "Incorrect CDB length %d, LUN 0x%016Lx on "
2078 "port 0x%016Lx closed\n",
2079 req
->qtcb
->bottom
.io
.fcp_cmnd_length
,
2080 (unsigned long long)zfcp_scsi_dev_lun(sdev
),
2081 (unsigned long long)zfcp_sdev
->port
->wwpn
);
2082 zfcp_erp_adapter_shutdown(zfcp_sdev
->port
->adapter
, 0,
2084 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2086 case FSF_PORT_BOXED
:
2087 zfcp_erp_set_port_status(zfcp_sdev
->port
,
2088 ZFCP_STATUS_COMMON_ACCESS_BOXED
);
2089 zfcp_erp_port_reopen(zfcp_sdev
->port
,
2090 ZFCP_STATUS_COMMON_ERP_FAILED
, "fssfch5");
2091 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2094 zfcp_erp_set_lun_status(sdev
, ZFCP_STATUS_COMMON_ACCESS_BOXED
);
2095 zfcp_erp_lun_reopen(sdev
, ZFCP_STATUS_COMMON_ERP_FAILED
,
2097 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2099 case FSF_ADAPTER_STATUS_AVAILABLE
:
2100 if (header
->fsf_status_qual
.word
[0] ==
2101 FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
)
2102 zfcp_fc_test_link(zfcp_sdev
->port
);
2103 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2108 static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req
*req
)
2110 struct scsi_cmnd
*scpnt
;
2111 struct fcp_resp_with_ext
*fcp_rsp
;
2112 unsigned long flags
;
2114 read_lock_irqsave(&req
->adapter
->abort_lock
, flags
);
2117 if (unlikely(!scpnt
)) {
2118 read_unlock_irqrestore(&req
->adapter
->abort_lock
, flags
);
2122 zfcp_fsf_fcp_handler_common(req
);
2124 if (unlikely(req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)) {
2125 set_host_byte(scpnt
, DID_TRANSPORT_DISRUPTED
);
2126 goto skip_fsfstatus
;
2129 switch (req
->qtcb
->header
.fsf_status
) {
2130 case FSF_INCONSISTENT_PROT_DATA
:
2131 case FSF_INVALID_PROT_PARM
:
2132 set_host_byte(scpnt
, DID_ERROR
);
2133 goto skip_fsfstatus
;
2134 case FSF_BLOCK_GUARD_CHECK_FAILURE
:
2135 zfcp_scsi_dif_sense_error(scpnt
, 0x1);
2136 goto skip_fsfstatus
;
2137 case FSF_APP_TAG_CHECK_FAILURE
:
2138 zfcp_scsi_dif_sense_error(scpnt
, 0x2);
2139 goto skip_fsfstatus
;
2140 case FSF_REF_TAG_CHECK_FAILURE
:
2141 zfcp_scsi_dif_sense_error(scpnt
, 0x3);
2142 goto skip_fsfstatus
;
2144 BUILD_BUG_ON(sizeof(struct fcp_resp_with_ext
) > FSF_FCP_RSP_SIZE
);
2145 fcp_rsp
= &req
->qtcb
->bottom
.io
.fcp_rsp
.iu
;
2146 zfcp_fc_eval_fcp_rsp(fcp_rsp
, scpnt
);
2149 zfcp_fsf_req_trace(req
, scpnt
);
2150 zfcp_dbf_scsi_result(scpnt
, req
);
2152 scpnt
->host_scribble
= NULL
;
2153 (scpnt
->scsi_done
) (scpnt
);
2155 * We must hold this lock until scsi_done has been called.
2156 * Otherwise we may call scsi_done after abort regarding this
2157 * command has completed.
2158 * Note: scsi_done must not block!
2160 read_unlock_irqrestore(&req
->adapter
->abort_lock
, flags
);
2163 static int zfcp_fsf_set_data_dir(struct scsi_cmnd
*scsi_cmnd
, u32
*data_dir
)
2165 switch (scsi_get_prot_op(scsi_cmnd
)) {
2166 case SCSI_PROT_NORMAL
:
2167 switch (scsi_cmnd
->sc_data_direction
) {
2169 *data_dir
= FSF_DATADIR_CMND
;
2171 case DMA_FROM_DEVICE
:
2172 *data_dir
= FSF_DATADIR_READ
;
2175 *data_dir
= FSF_DATADIR_WRITE
;
2177 case DMA_BIDIRECTIONAL
:
2182 case SCSI_PROT_READ_STRIP
:
2183 *data_dir
= FSF_DATADIR_DIF_READ_STRIP
;
2185 case SCSI_PROT_WRITE_INSERT
:
2186 *data_dir
= FSF_DATADIR_DIF_WRITE_INSERT
;
2188 case SCSI_PROT_READ_PASS
:
2189 *data_dir
= FSF_DATADIR_DIF_READ_CONVERT
;
2191 case SCSI_PROT_WRITE_PASS
:
2192 *data_dir
= FSF_DATADIR_DIF_WRITE_CONVERT
;
2202 * zfcp_fsf_fcp_cmnd - initiate an FCP command (for a SCSI command)
2203 * @scsi_cmnd: scsi command to be sent
2205 int zfcp_fsf_fcp_cmnd(struct scsi_cmnd
*scsi_cmnd
)
2207 struct zfcp_fsf_req
*req
;
2208 struct fcp_cmnd
*fcp_cmnd
;
2209 u8 sbtype
= SBAL_SFLAGS0_TYPE_READ
;
2211 struct scsi_device
*sdev
= scsi_cmnd
->device
;
2212 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
2213 struct zfcp_adapter
*adapter
= zfcp_sdev
->port
->adapter
;
2214 struct zfcp_qdio
*qdio
= adapter
->qdio
;
2215 struct fsf_qtcb_bottom_io
*io
;
2216 unsigned long flags
;
2218 if (unlikely(!(atomic_read(&zfcp_sdev
->status
) &
2219 ZFCP_STATUS_COMMON_UNBLOCKED
)))
2222 spin_lock_irqsave(&qdio
->req_q_lock
, flags
);
2223 if (atomic_read(&qdio
->req_q_free
) <= 0) {
2224 atomic_inc(&qdio
->req_q_full
);
2228 if (scsi_cmnd
->sc_data_direction
== DMA_TO_DEVICE
)
2229 sbtype
= SBAL_SFLAGS0_TYPE_WRITE
;
2231 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_FCP_CMND
,
2232 sbtype
, adapter
->pool
.scsi_req
);
2235 retval
= PTR_ERR(req
);
2239 scsi_cmnd
->host_scribble
= (unsigned char *) req
->req_id
;
2241 io
= &req
->qtcb
->bottom
.io
;
2242 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
2243 req
->data
= scsi_cmnd
;
2244 req
->handler
= zfcp_fsf_fcp_cmnd_handler
;
2245 req
->qtcb
->header
.lun_handle
= zfcp_sdev
->lun_handle
;
2246 req
->qtcb
->header
.port_handle
= zfcp_sdev
->port
->handle
;
2247 io
->service_class
= FSF_CLASS_3
;
2248 io
->fcp_cmnd_length
= FCP_CMND_LEN
;
2250 if (scsi_get_prot_op(scsi_cmnd
) != SCSI_PROT_NORMAL
) {
2251 io
->data_block_length
= scsi_cmnd
->device
->sector_size
;
2252 io
->ref_tag_value
= scsi_get_lba(scsi_cmnd
) & 0xFFFFFFFF;
2255 if (zfcp_fsf_set_data_dir(scsi_cmnd
, &io
->data_direction
))
2256 goto failed_scsi_cmnd
;
2258 BUILD_BUG_ON(sizeof(struct fcp_cmnd
) > FSF_FCP_CMND_SIZE
);
2259 fcp_cmnd
= &req
->qtcb
->bottom
.io
.fcp_cmnd
.iu
;
2260 zfcp_fc_scsi_to_fcp(fcp_cmnd
, scsi_cmnd
, 0);
2262 if ((scsi_get_prot_op(scsi_cmnd
) != SCSI_PROT_NORMAL
) &&
2263 scsi_prot_sg_count(scsi_cmnd
)) {
2264 zfcp_qdio_set_data_div(qdio
, &req
->qdio_req
,
2265 scsi_prot_sg_count(scsi_cmnd
));
2266 retval
= zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
,
2267 scsi_prot_sglist(scsi_cmnd
));
2269 goto failed_scsi_cmnd
;
2270 io
->prot_data_length
= zfcp_qdio_real_bytes(
2271 scsi_prot_sglist(scsi_cmnd
));
2274 retval
= zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
,
2275 scsi_sglist(scsi_cmnd
));
2276 if (unlikely(retval
))
2277 goto failed_scsi_cmnd
;
2279 zfcp_qdio_set_sbale_last(adapter
->qdio
, &req
->qdio_req
);
2280 if (zfcp_adapter_multi_buffer_active(adapter
))
2281 zfcp_qdio_set_scount(qdio
, &req
->qdio_req
);
2283 retval
= zfcp_fsf_req_send(req
);
2284 if (unlikely(retval
))
2285 goto failed_scsi_cmnd
;
2290 zfcp_fsf_req_free(req
);
2291 scsi_cmnd
->host_scribble
= NULL
;
2293 spin_unlock_irqrestore(&qdio
->req_q_lock
, flags
);
2297 static void zfcp_fsf_fcp_task_mgmt_handler(struct zfcp_fsf_req
*req
)
2299 struct fcp_resp_with_ext
*fcp_rsp
;
2300 struct fcp_resp_rsp_info
*rsp_info
;
2302 zfcp_fsf_fcp_handler_common(req
);
2304 fcp_rsp
= &req
->qtcb
->bottom
.io
.fcp_rsp
.iu
;
2305 rsp_info
= (struct fcp_resp_rsp_info
*) &fcp_rsp
[1];
2307 if ((rsp_info
->rsp_code
!= FCP_TMF_CMPL
) ||
2308 (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
))
2309 req
->status
|= ZFCP_STATUS_FSFREQ_TMFUNCFAILED
;
2313 * zfcp_fsf_fcp_task_mgmt - send SCSI task management command
2314 * @scmnd: SCSI command to send the task management command for
2315 * @tm_flags: unsigned byte for task management flags
2316 * Returns: on success pointer to struct fsf_req, NULL otherwise
2318 struct zfcp_fsf_req
*zfcp_fsf_fcp_task_mgmt(struct scsi_cmnd
*scmnd
,
2321 struct zfcp_fsf_req
*req
= NULL
;
2322 struct fcp_cmnd
*fcp_cmnd
;
2323 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(scmnd
->device
);
2324 struct zfcp_qdio
*qdio
= zfcp_sdev
->port
->adapter
->qdio
;
2326 if (unlikely(!(atomic_read(&zfcp_sdev
->status
) &
2327 ZFCP_STATUS_COMMON_UNBLOCKED
)))
2330 spin_lock_irq(&qdio
->req_q_lock
);
2331 if (zfcp_qdio_sbal_get(qdio
))
2334 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_FCP_CMND
,
2335 SBAL_SFLAGS0_TYPE_WRITE
,
2336 qdio
->adapter
->pool
.scsi_req
);
2344 req
->handler
= zfcp_fsf_fcp_task_mgmt_handler
;
2345 req
->qtcb
->header
.lun_handle
= zfcp_sdev
->lun_handle
;
2346 req
->qtcb
->header
.port_handle
= zfcp_sdev
->port
->handle
;
2347 req
->qtcb
->bottom
.io
.data_direction
= FSF_DATADIR_CMND
;
2348 req
->qtcb
->bottom
.io
.service_class
= FSF_CLASS_3
;
2349 req
->qtcb
->bottom
.io
.fcp_cmnd_length
= FCP_CMND_LEN
;
2351 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
2353 fcp_cmnd
= &req
->qtcb
->bottom
.io
.fcp_cmnd
.iu
;
2354 zfcp_fc_scsi_to_fcp(fcp_cmnd
, scmnd
, tm_flags
);
2356 zfcp_fsf_start_timer(req
, ZFCP_SCSI_ER_TIMEOUT
);
2357 if (!zfcp_fsf_req_send(req
))
2360 zfcp_fsf_req_free(req
);
2363 spin_unlock_irq(&qdio
->req_q_lock
);
2368 * zfcp_fsf_reqid_check - validate req_id contained in SBAL returned by QDIO
2369 * @adapter: pointer to struct zfcp_adapter
2370 * @sbal_idx: response queue index of SBAL to be processed
2372 void zfcp_fsf_reqid_check(struct zfcp_qdio
*qdio
, int sbal_idx
)
2374 struct zfcp_adapter
*adapter
= qdio
->adapter
;
2375 struct qdio_buffer
*sbal
= qdio
->res_q
[sbal_idx
];
2376 struct qdio_buffer_element
*sbale
;
2377 struct zfcp_fsf_req
*fsf_req
;
2378 unsigned long req_id
;
2381 for (idx
= 0; idx
< QDIO_MAX_ELEMENTS_PER_BUFFER
; idx
++) {
2383 sbale
= &sbal
->element
[idx
];
2384 req_id
= (unsigned long) sbale
->addr
;
2385 fsf_req
= zfcp_reqlist_find_rm(adapter
->req_list
, req_id
);
2389 * Unknown request means that we have potentially memory
2390 * corruption and must stop the machine immediately.
2392 zfcp_qdio_siosl(adapter
);
2393 panic("error: unknown req_id (%lx) on adapter %s.\n",
2394 req_id
, dev_name(&adapter
->ccw_device
->dev
));
2397 zfcp_fsf_req_complete(fsf_req
);
2399 if (likely(sbale
->eflags
& SBAL_EFLAGS_LAST_ENTRY
))