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 zfcp_fsf_link_down_info_eval(req
, ldi
);
202 case FSF_STATUS_READ_SUB_FDISC_FAILED
:
203 zfcp_fsf_link_down_info_eval(req
, ldi
);
205 case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE
:
206 zfcp_fsf_link_down_info_eval(req
, NULL
);
210 static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req
*req
)
212 struct zfcp_adapter
*adapter
= req
->adapter
;
213 struct fsf_status_read_buffer
*sr_buf
= req
->data
;
215 if (req
->status
& ZFCP_STATUS_FSFREQ_DISMISSED
) {
216 zfcp_dbf_hba_fsf_uss("fssrh_1", req
);
217 mempool_free(virt_to_page(sr_buf
), adapter
->pool
.sr_data
);
218 zfcp_fsf_req_free(req
);
222 zfcp_dbf_hba_fsf_uss("fssrh_4", req
);
224 switch (sr_buf
->status_type
) {
225 case FSF_STATUS_READ_PORT_CLOSED
:
226 zfcp_fsf_status_read_port_closed(req
);
228 case FSF_STATUS_READ_INCOMING_ELS
:
229 zfcp_fc_incoming_els(req
);
231 case FSF_STATUS_READ_SENSE_DATA_AVAIL
:
233 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD
:
234 dev_warn(&adapter
->ccw_device
->dev
,
235 "The error threshold for checksum statistics "
236 "has been exceeded\n");
237 zfcp_dbf_hba_bit_err("fssrh_3", req
);
239 case FSF_STATUS_READ_LINK_DOWN
:
240 zfcp_fsf_status_read_link_down(req
);
241 zfcp_fc_enqueue_event(adapter
, FCH_EVT_LINKDOWN
, 0);
243 case FSF_STATUS_READ_LINK_UP
:
244 dev_info(&adapter
->ccw_device
->dev
,
245 "The local link has been restored\n");
246 /* All ports should be marked as ready to run again */
247 zfcp_erp_set_adapter_status(adapter
,
248 ZFCP_STATUS_COMMON_RUNNING
);
249 zfcp_erp_adapter_reopen(adapter
,
250 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
|
251 ZFCP_STATUS_COMMON_ERP_FAILED
,
253 zfcp_fc_enqueue_event(adapter
, FCH_EVT_LINKUP
, 0);
256 case FSF_STATUS_READ_NOTIFICATION_LOST
:
257 if (sr_buf
->status_subtype
& FSF_STATUS_READ_SUB_INCOMING_ELS
)
258 zfcp_fc_conditional_port_scan(adapter
);
260 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT
:
261 adapter
->adapter_features
= sr_buf
->payload
.word
[0];
265 mempool_free(virt_to_page(sr_buf
), adapter
->pool
.sr_data
);
266 zfcp_fsf_req_free(req
);
268 atomic_inc(&adapter
->stat_miss
);
269 queue_work(adapter
->work_queue
, &adapter
->stat_work
);
272 static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req
*req
)
274 switch (req
->qtcb
->header
.fsf_status_qual
.word
[0]) {
275 case FSF_SQ_FCP_RSP_AVAILABLE
:
276 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
277 case FSF_SQ_NO_RETRY_POSSIBLE
:
278 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
280 case FSF_SQ_COMMAND_ABORTED
:
282 case FSF_SQ_NO_RECOM
:
283 dev_err(&req
->adapter
->ccw_device
->dev
,
284 "The FCP adapter reported a problem "
285 "that cannot be recovered\n");
286 zfcp_qdio_siosl(req
->adapter
);
287 zfcp_erp_adapter_shutdown(req
->adapter
, 0, "fsfsqe1");
290 /* all non-return stats set FSFREQ_ERROR*/
291 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
294 static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req
*req
)
296 if (unlikely(req
->status
& ZFCP_STATUS_FSFREQ_ERROR
))
299 switch (req
->qtcb
->header
.fsf_status
) {
300 case FSF_UNKNOWN_COMMAND
:
301 dev_err(&req
->adapter
->ccw_device
->dev
,
302 "The FCP adapter does not recognize the command 0x%x\n",
303 req
->qtcb
->header
.fsf_command
);
304 zfcp_erp_adapter_shutdown(req
->adapter
, 0, "fsfse_1");
305 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
307 case FSF_ADAPTER_STATUS_AVAILABLE
:
308 zfcp_fsf_fsfstatus_qual_eval(req
);
313 static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req
*req
)
315 struct zfcp_adapter
*adapter
= req
->adapter
;
316 struct fsf_qtcb
*qtcb
= req
->qtcb
;
317 union fsf_prot_status_qual
*psq
= &qtcb
->prefix
.prot_status_qual
;
319 zfcp_dbf_hba_fsf_response(req
);
321 if (req
->status
& ZFCP_STATUS_FSFREQ_DISMISSED
) {
322 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
326 switch (qtcb
->prefix
.prot_status
) {
328 case FSF_PROT_FSF_STATUS_PRESENTED
:
330 case FSF_PROT_QTCB_VERSION_ERROR
:
331 dev_err(&adapter
->ccw_device
->dev
,
332 "QTCB version 0x%x not supported by FCP adapter "
333 "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION
,
334 psq
->word
[0], psq
->word
[1]);
335 zfcp_erp_adapter_shutdown(adapter
, 0, "fspse_1");
337 case FSF_PROT_ERROR_STATE
:
338 case FSF_PROT_SEQ_NUMB_ERROR
:
339 zfcp_erp_adapter_reopen(adapter
, 0, "fspse_2");
340 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
342 case FSF_PROT_UNSUPP_QTCB_TYPE
:
343 dev_err(&adapter
->ccw_device
->dev
,
344 "The QTCB type is not supported by the FCP adapter\n");
345 zfcp_erp_adapter_shutdown(adapter
, 0, "fspse_3");
347 case FSF_PROT_HOST_CONNECTION_INITIALIZING
:
348 atomic_or(ZFCP_STATUS_ADAPTER_HOST_CON_INIT
,
351 case FSF_PROT_DUPLICATE_REQUEST_ID
:
352 dev_err(&adapter
->ccw_device
->dev
,
353 "0x%Lx is an ambiguous request identifier\n",
354 (unsigned long long)qtcb
->bottom
.support
.req_handle
);
355 zfcp_erp_adapter_shutdown(adapter
, 0, "fspse_4");
357 case FSF_PROT_LINK_DOWN
:
358 zfcp_fsf_link_down_info_eval(req
, &psq
->link_down_info
);
359 /* go through reopen to flush pending requests */
360 zfcp_erp_adapter_reopen(adapter
, 0, "fspse_6");
362 case FSF_PROT_REEST_QUEUE
:
363 /* All ports should be marked as ready to run again */
364 zfcp_erp_set_adapter_status(adapter
,
365 ZFCP_STATUS_COMMON_RUNNING
);
366 zfcp_erp_adapter_reopen(adapter
,
367 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
|
368 ZFCP_STATUS_COMMON_ERP_FAILED
,
372 dev_err(&adapter
->ccw_device
->dev
,
373 "0x%x is not a valid transfer protocol status\n",
374 qtcb
->prefix
.prot_status
);
375 zfcp_qdio_siosl(adapter
);
376 zfcp_erp_adapter_shutdown(adapter
, 0, "fspse_9");
378 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
382 * zfcp_fsf_req_complete - process completion of a FSF request
383 * @fsf_req: The FSF request that has been completed.
385 * When a request has been completed either from the FCP adapter,
386 * or it has been dismissed due to a queue shutdown, this function
387 * is called to process the completion status and trigger further
388 * events related to the FSF request.
390 static void zfcp_fsf_req_complete(struct zfcp_fsf_req
*req
)
392 if (unlikely(req
->fsf_command
== FSF_QTCB_UNSOLICITED_STATUS
)) {
393 zfcp_fsf_status_read_handler(req
);
397 del_timer(&req
->timer
);
398 zfcp_fsf_protstatus_eval(req
);
399 zfcp_fsf_fsfstatus_eval(req
);
403 zfcp_erp_notify(req
->erp_action
, 0);
405 if (likely(req
->status
& ZFCP_STATUS_FSFREQ_CLEANUP
))
406 zfcp_fsf_req_free(req
);
408 complete(&req
->completion
);
412 * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
413 * @adapter: pointer to struct zfcp_adapter
415 * Never ever call this without shutting down the adapter first.
416 * Otherwise the adapter would continue using and corrupting s390 storage.
417 * Included BUG_ON() call to ensure this is done.
418 * ERP is supposed to be the only user of this function.
420 void zfcp_fsf_req_dismiss_all(struct zfcp_adapter
*adapter
)
422 struct zfcp_fsf_req
*req
, *tmp
;
423 LIST_HEAD(remove_queue
);
425 BUG_ON(atomic_read(&adapter
->status
) & ZFCP_STATUS_ADAPTER_QDIOUP
);
426 zfcp_reqlist_move(adapter
->req_list
, &remove_queue
);
428 list_for_each_entry_safe(req
, tmp
, &remove_queue
, list
) {
429 list_del(&req
->list
);
430 req
->status
|= ZFCP_STATUS_FSFREQ_DISMISSED
;
431 zfcp_fsf_req_complete(req
);
435 #define ZFCP_FSF_PORTSPEED_1GBIT (1 << 0)
436 #define ZFCP_FSF_PORTSPEED_2GBIT (1 << 1)
437 #define ZFCP_FSF_PORTSPEED_4GBIT (1 << 2)
438 #define ZFCP_FSF_PORTSPEED_10GBIT (1 << 3)
439 #define ZFCP_FSF_PORTSPEED_8GBIT (1 << 4)
440 #define ZFCP_FSF_PORTSPEED_16GBIT (1 << 5)
441 #define ZFCP_FSF_PORTSPEED_NOT_NEGOTIATED (1 << 15)
443 static u32
zfcp_fsf_convert_portspeed(u32 fsf_speed
)
446 if (fsf_speed
& ZFCP_FSF_PORTSPEED_1GBIT
)
447 fdmi_speed
|= FC_PORTSPEED_1GBIT
;
448 if (fsf_speed
& ZFCP_FSF_PORTSPEED_2GBIT
)
449 fdmi_speed
|= FC_PORTSPEED_2GBIT
;
450 if (fsf_speed
& ZFCP_FSF_PORTSPEED_4GBIT
)
451 fdmi_speed
|= FC_PORTSPEED_4GBIT
;
452 if (fsf_speed
& ZFCP_FSF_PORTSPEED_10GBIT
)
453 fdmi_speed
|= FC_PORTSPEED_10GBIT
;
454 if (fsf_speed
& ZFCP_FSF_PORTSPEED_8GBIT
)
455 fdmi_speed
|= FC_PORTSPEED_8GBIT
;
456 if (fsf_speed
& ZFCP_FSF_PORTSPEED_16GBIT
)
457 fdmi_speed
|= FC_PORTSPEED_16GBIT
;
458 if (fsf_speed
& ZFCP_FSF_PORTSPEED_NOT_NEGOTIATED
)
459 fdmi_speed
|= FC_PORTSPEED_NOT_NEGOTIATED
;
463 static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req
*req
)
465 struct fsf_qtcb_bottom_config
*bottom
= &req
->qtcb
->bottom
.config
;
466 struct zfcp_adapter
*adapter
= req
->adapter
;
467 struct Scsi_Host
*shost
= adapter
->scsi_host
;
468 struct fc_els_flogi
*nsp
, *plogi
;
470 /* adjust pointers for missing command code */
471 nsp
= (struct fc_els_flogi
*) ((u8
*)&bottom
->nport_serv_param
473 plogi
= (struct fc_els_flogi
*) ((u8
*)&bottom
->plogi_payload
477 memcpy(req
->data
, bottom
, sizeof(*bottom
));
479 fc_host_port_name(shost
) = be64_to_cpu(nsp
->fl_wwpn
);
480 fc_host_node_name(shost
) = be64_to_cpu(nsp
->fl_wwnn
);
481 fc_host_supported_classes(shost
) = FC_COS_CLASS2
| FC_COS_CLASS3
;
483 adapter
->timer_ticks
= bottom
->timer_interval
& ZFCP_FSF_TIMER_INT_MASK
;
484 adapter
->stat_read_buf_num
= max(bottom
->status_read_buf_num
,
485 (u16
)FSF_STATUS_READS_RECOM
);
487 if (fc_host_permanent_port_name(shost
) == -1)
488 fc_host_permanent_port_name(shost
) = fc_host_port_name(shost
);
490 zfcp_scsi_set_prot(adapter
);
492 /* no error return above here, otherwise must fix call chains */
493 /* do not evaluate invalid fields */
494 if (req
->qtcb
->header
.fsf_status
== FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE
)
497 fc_host_port_id(shost
) = ntoh24(bottom
->s_id
);
498 fc_host_speed(shost
) =
499 zfcp_fsf_convert_portspeed(bottom
->fc_link_speed
);
501 adapter
->hydra_version
= bottom
->adapter_type
;
503 switch (bottom
->fc_topology
) {
505 adapter
->peer_d_id
= ntoh24(bottom
->peer_d_id
);
506 adapter
->peer_wwpn
= be64_to_cpu(plogi
->fl_wwpn
);
507 adapter
->peer_wwnn
= be64_to_cpu(plogi
->fl_wwnn
);
508 fc_host_port_type(shost
) = FC_PORTTYPE_PTP
;
510 case FSF_TOPO_FABRIC
:
511 if (bottom
->connection_features
& FSF_FEATURE_NPIV_MODE
)
512 fc_host_port_type(shost
) = FC_PORTTYPE_NPIV
;
514 fc_host_port_type(shost
) = FC_PORTTYPE_NPORT
;
517 fc_host_port_type(shost
) = FC_PORTTYPE_NLPORT
;
520 dev_err(&adapter
->ccw_device
->dev
,
521 "Unknown or unsupported arbitrated loop "
522 "fibre channel topology detected\n");
523 zfcp_erp_adapter_shutdown(adapter
, 0, "fsece_1");
530 static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req
*req
)
532 struct zfcp_adapter
*adapter
= req
->adapter
;
533 struct fsf_qtcb
*qtcb
= req
->qtcb
;
534 struct fsf_qtcb_bottom_config
*bottom
= &qtcb
->bottom
.config
;
535 struct Scsi_Host
*shost
= adapter
->scsi_host
;
537 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
540 adapter
->fsf_lic_version
= bottom
->lic_version
;
541 adapter
->adapter_features
= bottom
->adapter_features
;
542 adapter
->connection_features
= bottom
->connection_features
;
543 adapter
->peer_wwpn
= 0;
544 adapter
->peer_wwnn
= 0;
545 adapter
->peer_d_id
= 0;
547 switch (qtcb
->header
.fsf_status
) {
549 if (zfcp_fsf_exchange_config_evaluate(req
))
552 if (bottom
->max_qtcb_size
< sizeof(struct fsf_qtcb
)) {
553 dev_err(&adapter
->ccw_device
->dev
,
554 "FCP adapter maximum QTCB size (%d bytes) "
556 bottom
->max_qtcb_size
);
557 zfcp_erp_adapter_shutdown(adapter
, 0, "fsecdh1");
560 atomic_or(ZFCP_STATUS_ADAPTER_XCONFIG_OK
,
563 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE
:
564 fc_host_node_name(shost
) = 0;
565 fc_host_port_name(shost
) = 0;
566 fc_host_port_id(shost
) = 0;
567 fc_host_speed(shost
) = FC_PORTSPEED_UNKNOWN
;
568 fc_host_port_type(shost
) = FC_PORTTYPE_UNKNOWN
;
569 adapter
->hydra_version
= 0;
571 /* avoids adapter shutdown to be able to recognize
572 * events such as LINK UP */
573 atomic_or(ZFCP_STATUS_ADAPTER_XCONFIG_OK
,
575 zfcp_fsf_link_down_info_eval(req
,
576 &qtcb
->header
.fsf_status_qual
.link_down_info
);
577 if (zfcp_fsf_exchange_config_evaluate(req
))
581 zfcp_erp_adapter_shutdown(adapter
, 0, "fsecdh3");
585 if (adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
) {
586 adapter
->hardware_version
= bottom
->hardware_version
;
587 memcpy(fc_host_serial_number(shost
), bottom
->serial_number
,
588 min(FC_SERIAL_NUMBER_SIZE
, 17));
589 EBCASC(fc_host_serial_number(shost
),
590 min(FC_SERIAL_NUMBER_SIZE
, 17));
593 if (FSF_QTCB_CURRENT_VERSION
< bottom
->low_qtcb_version
) {
594 dev_err(&adapter
->ccw_device
->dev
,
595 "The FCP adapter only supports newer "
596 "control block versions\n");
597 zfcp_erp_adapter_shutdown(adapter
, 0, "fsecdh4");
600 if (FSF_QTCB_CURRENT_VERSION
> bottom
->high_qtcb_version
) {
601 dev_err(&adapter
->ccw_device
->dev
,
602 "The FCP adapter only supports older "
603 "control block versions\n");
604 zfcp_erp_adapter_shutdown(adapter
, 0, "fsecdh5");
608 static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req
*req
)
610 struct zfcp_adapter
*adapter
= req
->adapter
;
611 struct fsf_qtcb_bottom_port
*bottom
= &req
->qtcb
->bottom
.port
;
612 struct Scsi_Host
*shost
= adapter
->scsi_host
;
615 memcpy(req
->data
, bottom
, sizeof(*bottom
));
617 if (adapter
->connection_features
& FSF_FEATURE_NPIV_MODE
) {
618 fc_host_permanent_port_name(shost
) = bottom
->wwpn
;
620 fc_host_permanent_port_name(shost
) = fc_host_port_name(shost
);
621 fc_host_maxframe_size(shost
) = bottom
->maximum_frame_size
;
622 fc_host_supported_speeds(shost
) =
623 zfcp_fsf_convert_portspeed(bottom
->supported_speed
);
624 memcpy(fc_host_supported_fc4s(shost
), bottom
->supported_fc4_types
,
626 memcpy(fc_host_active_fc4s(shost
), bottom
->active_fc4_types
,
630 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req
*req
)
632 struct fsf_qtcb
*qtcb
= req
->qtcb
;
634 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
637 switch (qtcb
->header
.fsf_status
) {
639 zfcp_fsf_exchange_port_evaluate(req
);
641 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE
:
642 zfcp_fsf_exchange_port_evaluate(req
);
643 zfcp_fsf_link_down_info_eval(req
,
644 &qtcb
->header
.fsf_status_qual
.link_down_info
);
649 static struct zfcp_fsf_req
*zfcp_fsf_alloc(mempool_t
*pool
)
651 struct zfcp_fsf_req
*req
;
654 req
= mempool_alloc(pool
, GFP_ATOMIC
);
656 req
= kmalloc(sizeof(*req
), GFP_ATOMIC
);
661 memset(req
, 0, sizeof(*req
));
666 static struct fsf_qtcb
*zfcp_qtcb_alloc(mempool_t
*pool
)
668 struct fsf_qtcb
*qtcb
;
671 qtcb
= mempool_alloc(pool
, GFP_ATOMIC
);
673 qtcb
= kmem_cache_alloc(zfcp_fsf_qtcb_cache
, GFP_ATOMIC
);
678 memset(qtcb
, 0, sizeof(*qtcb
));
682 static struct zfcp_fsf_req
*zfcp_fsf_req_create(struct zfcp_qdio
*qdio
,
683 u32 fsf_cmd
, u8 sbtype
,
686 struct zfcp_adapter
*adapter
= qdio
->adapter
;
687 struct zfcp_fsf_req
*req
= zfcp_fsf_alloc(pool
);
690 return ERR_PTR(-ENOMEM
);
692 if (adapter
->req_no
== 0)
695 INIT_LIST_HEAD(&req
->list
);
696 init_timer(&req
->timer
);
697 init_completion(&req
->completion
);
699 req
->adapter
= adapter
;
700 req
->fsf_command
= fsf_cmd
;
701 req
->req_id
= adapter
->req_no
;
703 if (likely(fsf_cmd
!= FSF_QTCB_UNSOLICITED_STATUS
)) {
705 req
->qtcb
= zfcp_qtcb_alloc(adapter
->pool
.qtcb_pool
);
707 req
->qtcb
= zfcp_qtcb_alloc(NULL
);
709 if (unlikely(!req
->qtcb
)) {
710 zfcp_fsf_req_free(req
);
711 return ERR_PTR(-ENOMEM
);
714 req
->seq_no
= adapter
->fsf_req_seq_no
;
715 req
->qtcb
->prefix
.req_seq_no
= adapter
->fsf_req_seq_no
;
716 req
->qtcb
->prefix
.req_id
= req
->req_id
;
717 req
->qtcb
->prefix
.ulp_info
= 26;
718 req
->qtcb
->prefix
.qtcb_type
= fsf_qtcb_type
[req
->fsf_command
];
719 req
->qtcb
->prefix
.qtcb_version
= FSF_QTCB_CURRENT_VERSION
;
720 req
->qtcb
->header
.req_handle
= req
->req_id
;
721 req
->qtcb
->header
.fsf_command
= req
->fsf_command
;
724 zfcp_qdio_req_init(adapter
->qdio
, &req
->qdio_req
, req
->req_id
, sbtype
,
725 req
->qtcb
, sizeof(struct fsf_qtcb
));
730 static int zfcp_fsf_req_send(struct zfcp_fsf_req
*req
)
732 struct zfcp_adapter
*adapter
= req
->adapter
;
733 struct zfcp_qdio
*qdio
= adapter
->qdio
;
734 int with_qtcb
= (req
->qtcb
!= NULL
);
735 int req_id
= req
->req_id
;
737 zfcp_reqlist_add(adapter
->req_list
, req
);
739 req
->qdio_req
.qdio_outb_usage
= atomic_read(&qdio
->req_q_free
);
740 req
->issued
= get_tod_clock();
741 if (zfcp_qdio_send(qdio
, &req
->qdio_req
)) {
742 del_timer(&req
->timer
);
743 /* lookup request again, list might have changed */
744 zfcp_reqlist_find_rm(adapter
->req_list
, req_id
);
745 zfcp_erp_adapter_reopen(adapter
, 0, "fsrs__1");
749 /* Don't increase for unsolicited status */
751 adapter
->fsf_req_seq_no
++;
758 * zfcp_fsf_status_read - send status read request
759 * @adapter: pointer to struct zfcp_adapter
760 * @req_flags: request flags
761 * Returns: 0 on success, ERROR otherwise
763 int zfcp_fsf_status_read(struct zfcp_qdio
*qdio
)
765 struct zfcp_adapter
*adapter
= qdio
->adapter
;
766 struct zfcp_fsf_req
*req
;
767 struct fsf_status_read_buffer
*sr_buf
;
771 spin_lock_irq(&qdio
->req_q_lock
);
772 if (zfcp_qdio_sbal_get(qdio
))
775 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_UNSOLICITED_STATUS
,
776 SBAL_SFLAGS0_TYPE_STATUS
,
777 adapter
->pool
.status_read_req
);
779 retval
= PTR_ERR(req
);
783 page
= mempool_alloc(adapter
->pool
.sr_data
, GFP_ATOMIC
);
788 sr_buf
= page_address(page
);
789 memset(sr_buf
, 0, sizeof(*sr_buf
));
792 zfcp_qdio_fill_next(qdio
, &req
->qdio_req
, sr_buf
, sizeof(*sr_buf
));
793 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
795 retval
= zfcp_fsf_req_send(req
);
797 goto failed_req_send
;
803 mempool_free(virt_to_page(sr_buf
), adapter
->pool
.sr_data
);
805 zfcp_dbf_hba_fsf_uss("fssr__1", req
);
806 zfcp_fsf_req_free(req
);
808 spin_unlock_irq(&qdio
->req_q_lock
);
812 static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req
*req
)
814 struct scsi_device
*sdev
= req
->data
;
815 struct zfcp_scsi_dev
*zfcp_sdev
;
816 union fsf_status_qual
*fsq
= &req
->qtcb
->header
.fsf_status_qual
;
818 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
821 zfcp_sdev
= sdev_to_zfcp(sdev
);
823 switch (req
->qtcb
->header
.fsf_status
) {
824 case FSF_PORT_HANDLE_NOT_VALID
:
825 if (fsq
->word
[0] == fsq
->word
[1]) {
826 zfcp_erp_adapter_reopen(zfcp_sdev
->port
->adapter
, 0,
828 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
831 case FSF_LUN_HANDLE_NOT_VALID
:
832 if (fsq
->word
[0] == fsq
->word
[1]) {
833 zfcp_erp_port_reopen(zfcp_sdev
->port
, 0, "fsafch2");
834 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
837 case FSF_FCP_COMMAND_DOES_NOT_EXIST
:
838 req
->status
|= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED
;
841 zfcp_erp_set_port_status(zfcp_sdev
->port
,
842 ZFCP_STATUS_COMMON_ACCESS_BOXED
);
843 zfcp_erp_port_reopen(zfcp_sdev
->port
,
844 ZFCP_STATUS_COMMON_ERP_FAILED
, "fsafch3");
845 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
848 zfcp_erp_set_lun_status(sdev
, ZFCP_STATUS_COMMON_ACCESS_BOXED
);
849 zfcp_erp_lun_reopen(sdev
, ZFCP_STATUS_COMMON_ERP_FAILED
,
851 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
853 case FSF_ADAPTER_STATUS_AVAILABLE
:
854 switch (fsq
->word
[0]) {
855 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
856 zfcp_fc_test_link(zfcp_sdev
->port
);
858 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
859 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
864 req
->status
|= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED
;
870 * zfcp_fsf_abort_fcp_cmnd - abort running SCSI command
871 * @scmnd: The SCSI command to abort
872 * Returns: pointer to struct zfcp_fsf_req
875 struct zfcp_fsf_req
*zfcp_fsf_abort_fcp_cmnd(struct scsi_cmnd
*scmnd
)
877 struct zfcp_fsf_req
*req
= NULL
;
878 struct scsi_device
*sdev
= scmnd
->device
;
879 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
880 struct zfcp_qdio
*qdio
= zfcp_sdev
->port
->adapter
->qdio
;
881 unsigned long old_req_id
= (unsigned long) scmnd
->host_scribble
;
883 spin_lock_irq(&qdio
->req_q_lock
);
884 if (zfcp_qdio_sbal_get(qdio
))
886 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_ABORT_FCP_CMND
,
887 SBAL_SFLAGS0_TYPE_READ
,
888 qdio
->adapter
->pool
.scsi_abort
);
894 if (unlikely(!(atomic_read(&zfcp_sdev
->status
) &
895 ZFCP_STATUS_COMMON_UNBLOCKED
)))
898 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
901 req
->handler
= zfcp_fsf_abort_fcp_command_handler
;
902 req
->qtcb
->header
.lun_handle
= zfcp_sdev
->lun_handle
;
903 req
->qtcb
->header
.port_handle
= zfcp_sdev
->port
->handle
;
904 req
->qtcb
->bottom
.support
.req_handle
= (u64
) old_req_id
;
906 zfcp_fsf_start_timer(req
, ZFCP_SCSI_ER_TIMEOUT
);
907 if (!zfcp_fsf_req_send(req
))
911 zfcp_fsf_req_free(req
);
914 spin_unlock_irq(&qdio
->req_q_lock
);
918 static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req
*req
)
920 struct zfcp_adapter
*adapter
= req
->adapter
;
921 struct zfcp_fsf_ct_els
*ct
= req
->data
;
922 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
924 ct
->status
= -EINVAL
;
926 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
929 switch (header
->fsf_status
) {
932 zfcp_dbf_san_res("fsscth2", req
);
934 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
935 zfcp_fsf_class_not_supp(req
);
937 case FSF_ADAPTER_STATUS_AVAILABLE
:
938 switch (header
->fsf_status_qual
.word
[0]){
939 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
940 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
941 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
946 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
948 case FSF_PORT_HANDLE_NOT_VALID
:
949 zfcp_erp_adapter_reopen(adapter
, 0, "fsscth1");
951 case FSF_GENERIC_COMMAND_REJECTED
:
952 case FSF_PAYLOAD_SIZE_MISMATCH
:
953 case FSF_REQUEST_SIZE_TOO_LARGE
:
954 case FSF_RESPONSE_SIZE_TOO_LARGE
:
955 case FSF_SBAL_MISMATCH
:
956 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
962 ct
->handler(ct
->handler_data
);
965 static void zfcp_fsf_setup_ct_els_unchained(struct zfcp_qdio
*qdio
,
966 struct zfcp_qdio_req
*q_req
,
967 struct scatterlist
*sg_req
,
968 struct scatterlist
*sg_resp
)
970 zfcp_qdio_fill_next(qdio
, q_req
, sg_virt(sg_req
), sg_req
->length
);
971 zfcp_qdio_fill_next(qdio
, q_req
, sg_virt(sg_resp
), sg_resp
->length
);
972 zfcp_qdio_set_sbale_last(qdio
, q_req
);
975 static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req
*req
,
976 struct scatterlist
*sg_req
,
977 struct scatterlist
*sg_resp
)
979 struct zfcp_adapter
*adapter
= req
->adapter
;
980 struct zfcp_qdio
*qdio
= adapter
->qdio
;
981 struct fsf_qtcb
*qtcb
= req
->qtcb
;
982 u32 feat
= adapter
->adapter_features
;
984 if (zfcp_adapter_multi_buffer_active(adapter
)) {
985 if (zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
, sg_req
))
987 qtcb
->bottom
.support
.req_buf_length
=
988 zfcp_qdio_real_bytes(sg_req
);
989 if (zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
, sg_resp
))
991 qtcb
->bottom
.support
.resp_buf_length
=
992 zfcp_qdio_real_bytes(sg_resp
);
994 zfcp_qdio_set_data_div(qdio
, &req
->qdio_req
, sg_nents(sg_req
));
995 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
996 zfcp_qdio_set_scount(qdio
, &req
->qdio_req
);
1000 /* use single, unchained SBAL if it can hold the request */
1001 if (zfcp_qdio_sg_one_sbale(sg_req
) && zfcp_qdio_sg_one_sbale(sg_resp
)) {
1002 zfcp_fsf_setup_ct_els_unchained(qdio
, &req
->qdio_req
,
1007 if (!(feat
& FSF_FEATURE_ELS_CT_CHAINED_SBALS
))
1010 if (zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
, sg_req
))
1013 qtcb
->bottom
.support
.req_buf_length
= zfcp_qdio_real_bytes(sg_req
);
1015 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1016 zfcp_qdio_skip_to_last_sbale(qdio
, &req
->qdio_req
);
1018 if (zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
, sg_resp
))
1021 qtcb
->bottom
.support
.resp_buf_length
= zfcp_qdio_real_bytes(sg_resp
);
1023 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1028 static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req
*req
,
1029 struct scatterlist
*sg_req
,
1030 struct scatterlist
*sg_resp
,
1031 unsigned int timeout
)
1035 ret
= zfcp_fsf_setup_ct_els_sbals(req
, sg_req
, sg_resp
);
1039 /* common settings for ct/gs and els requests */
1041 timeout
= 255; /* max value accepted by hardware */
1042 req
->qtcb
->bottom
.support
.service_class
= FSF_CLASS_3
;
1043 req
->qtcb
->bottom
.support
.timeout
= timeout
;
1044 zfcp_fsf_start_timer(req
, (timeout
+ 10) * HZ
);
1050 * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
1051 * @ct: pointer to struct zfcp_send_ct with data for request
1052 * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
1054 int zfcp_fsf_send_ct(struct zfcp_fc_wka_port
*wka_port
,
1055 struct zfcp_fsf_ct_els
*ct
, mempool_t
*pool
,
1056 unsigned int timeout
)
1058 struct zfcp_qdio
*qdio
= wka_port
->adapter
->qdio
;
1059 struct zfcp_fsf_req
*req
;
1062 spin_lock_irq(&qdio
->req_q_lock
);
1063 if (zfcp_qdio_sbal_get(qdio
))
1066 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_SEND_GENERIC
,
1067 SBAL_SFLAGS0_TYPE_WRITE_READ
, pool
);
1074 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1075 ret
= zfcp_fsf_setup_ct_els(req
, ct
->req
, ct
->resp
, timeout
);
1079 req
->handler
= zfcp_fsf_send_ct_handler
;
1080 req
->qtcb
->header
.port_handle
= wka_port
->handle
;
1081 ct
->d_id
= wka_port
->d_id
;
1084 zfcp_dbf_san_req("fssct_1", req
, wka_port
->d_id
);
1086 ret
= zfcp_fsf_req_send(req
);
1093 zfcp_fsf_req_free(req
);
1095 spin_unlock_irq(&qdio
->req_q_lock
);
1099 static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req
*req
)
1101 struct zfcp_fsf_ct_els
*send_els
= req
->data
;
1102 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1104 send_els
->status
= -EINVAL
;
1106 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1107 goto skip_fsfstatus
;
1109 switch (header
->fsf_status
) {
1111 send_els
->status
= 0;
1112 zfcp_dbf_san_res("fsselh1", req
);
1114 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
1115 zfcp_fsf_class_not_supp(req
);
1117 case FSF_ADAPTER_STATUS_AVAILABLE
:
1118 switch (header
->fsf_status_qual
.word
[0]){
1119 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1120 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1121 case FSF_SQ_RETRY_IF_POSSIBLE
:
1122 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1126 case FSF_ELS_COMMAND_REJECTED
:
1127 case FSF_PAYLOAD_SIZE_MISMATCH
:
1128 case FSF_REQUEST_SIZE_TOO_LARGE
:
1129 case FSF_RESPONSE_SIZE_TOO_LARGE
:
1131 case FSF_SBAL_MISMATCH
:
1132 /* should never occur, avoided in zfcp_fsf_send_els */
1135 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1139 if (send_els
->handler
)
1140 send_els
->handler(send_els
->handler_data
);
1144 * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
1145 * @els: pointer to struct zfcp_send_els with data for the command
1147 int zfcp_fsf_send_els(struct zfcp_adapter
*adapter
, u32 d_id
,
1148 struct zfcp_fsf_ct_els
*els
, unsigned int timeout
)
1150 struct zfcp_fsf_req
*req
;
1151 struct zfcp_qdio
*qdio
= adapter
->qdio
;
1154 spin_lock_irq(&qdio
->req_q_lock
);
1155 if (zfcp_qdio_sbal_get(qdio
))
1158 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_SEND_ELS
,
1159 SBAL_SFLAGS0_TYPE_WRITE_READ
, NULL
);
1166 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1168 if (!zfcp_adapter_multi_buffer_active(adapter
))
1169 zfcp_qdio_sbal_limit(qdio
, &req
->qdio_req
, 2);
1171 ret
= zfcp_fsf_setup_ct_els(req
, els
->req
, els
->resp
, timeout
);
1176 hton24(req
->qtcb
->bottom
.support
.d_id
, d_id
);
1177 req
->handler
= zfcp_fsf_send_els_handler
;
1181 zfcp_dbf_san_req("fssels1", req
, d_id
);
1183 ret
= zfcp_fsf_req_send(req
);
1190 zfcp_fsf_req_free(req
);
1192 spin_unlock_irq(&qdio
->req_q_lock
);
1196 int zfcp_fsf_exchange_config_data(struct zfcp_erp_action
*erp_action
)
1198 struct zfcp_fsf_req
*req
;
1199 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1202 spin_lock_irq(&qdio
->req_q_lock
);
1203 if (zfcp_qdio_sbal_get(qdio
))
1206 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_EXCHANGE_CONFIG_DATA
,
1207 SBAL_SFLAGS0_TYPE_READ
,
1208 qdio
->adapter
->pool
.erp_req
);
1211 retval
= PTR_ERR(req
);
1215 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1216 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1218 req
->qtcb
->bottom
.config
.feature_selection
=
1219 FSF_FEATURE_NOTIFICATION_LOST
|
1220 FSF_FEATURE_UPDATE_ALERT
;
1221 req
->erp_action
= erp_action
;
1222 req
->handler
= zfcp_fsf_exchange_config_data_handler
;
1223 erp_action
->fsf_req_id
= req
->req_id
;
1225 zfcp_fsf_start_erp_timer(req
);
1226 retval
= zfcp_fsf_req_send(req
);
1228 zfcp_fsf_req_free(req
);
1229 erp_action
->fsf_req_id
= 0;
1232 spin_unlock_irq(&qdio
->req_q_lock
);
1236 int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio
*qdio
,
1237 struct fsf_qtcb_bottom_config
*data
)
1239 struct zfcp_fsf_req
*req
= NULL
;
1242 spin_lock_irq(&qdio
->req_q_lock
);
1243 if (zfcp_qdio_sbal_get(qdio
))
1246 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_EXCHANGE_CONFIG_DATA
,
1247 SBAL_SFLAGS0_TYPE_READ
, NULL
);
1250 retval
= PTR_ERR(req
);
1254 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1255 req
->handler
= zfcp_fsf_exchange_config_data_handler
;
1257 req
->qtcb
->bottom
.config
.feature_selection
=
1258 FSF_FEATURE_NOTIFICATION_LOST
|
1259 FSF_FEATURE_UPDATE_ALERT
;
1264 zfcp_fsf_start_timer(req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1265 retval
= zfcp_fsf_req_send(req
);
1266 spin_unlock_irq(&qdio
->req_q_lock
);
1268 wait_for_completion(&req
->completion
);
1270 zfcp_fsf_req_free(req
);
1274 spin_unlock_irq(&qdio
->req_q_lock
);
1279 * zfcp_fsf_exchange_port_data - request information about local port
1280 * @erp_action: ERP action for the adapter for which port data is requested
1281 * Returns: 0 on success, error otherwise
1283 int zfcp_fsf_exchange_port_data(struct zfcp_erp_action
*erp_action
)
1285 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1286 struct zfcp_fsf_req
*req
;
1289 if (!(qdio
->adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
))
1292 spin_lock_irq(&qdio
->req_q_lock
);
1293 if (zfcp_qdio_sbal_get(qdio
))
1296 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_EXCHANGE_PORT_DATA
,
1297 SBAL_SFLAGS0_TYPE_READ
,
1298 qdio
->adapter
->pool
.erp_req
);
1301 retval
= PTR_ERR(req
);
1305 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1306 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1308 req
->handler
= zfcp_fsf_exchange_port_data_handler
;
1309 req
->erp_action
= erp_action
;
1310 erp_action
->fsf_req_id
= req
->req_id
;
1312 zfcp_fsf_start_erp_timer(req
);
1313 retval
= zfcp_fsf_req_send(req
);
1315 zfcp_fsf_req_free(req
);
1316 erp_action
->fsf_req_id
= 0;
1319 spin_unlock_irq(&qdio
->req_q_lock
);
1324 * zfcp_fsf_exchange_port_data_sync - request information about local port
1325 * @qdio: pointer to struct zfcp_qdio
1326 * @data: pointer to struct fsf_qtcb_bottom_port
1327 * Returns: 0 on success, error otherwise
1329 int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio
*qdio
,
1330 struct fsf_qtcb_bottom_port
*data
)
1332 struct zfcp_fsf_req
*req
= NULL
;
1335 if (!(qdio
->adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
))
1338 spin_lock_irq(&qdio
->req_q_lock
);
1339 if (zfcp_qdio_sbal_get(qdio
))
1342 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_EXCHANGE_PORT_DATA
,
1343 SBAL_SFLAGS0_TYPE_READ
, NULL
);
1346 retval
= PTR_ERR(req
);
1353 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1355 req
->handler
= zfcp_fsf_exchange_port_data_handler
;
1356 zfcp_fsf_start_timer(req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1357 retval
= zfcp_fsf_req_send(req
);
1358 spin_unlock_irq(&qdio
->req_q_lock
);
1361 wait_for_completion(&req
->completion
);
1363 zfcp_fsf_req_free(req
);
1368 spin_unlock_irq(&qdio
->req_q_lock
);
1372 static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req
*req
)
1374 struct zfcp_port
*port
= req
->data
;
1375 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1376 struct fc_els_flogi
*plogi
;
1378 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1381 switch (header
->fsf_status
) {
1382 case FSF_PORT_ALREADY_OPEN
:
1384 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED
:
1385 dev_warn(&req
->adapter
->ccw_device
->dev
,
1386 "Not enough FCP adapter resources to open "
1387 "remote port 0x%016Lx\n",
1388 (unsigned long long)port
->wwpn
);
1389 zfcp_erp_set_port_status(port
,
1390 ZFCP_STATUS_COMMON_ERP_FAILED
);
1391 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1393 case FSF_ADAPTER_STATUS_AVAILABLE
:
1394 switch (header
->fsf_status_qual
.word
[0]) {
1395 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1396 /* no zfcp_fc_test_link() with failed open port */
1398 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1399 case FSF_SQ_NO_RETRY_POSSIBLE
:
1400 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1405 port
->handle
= header
->port_handle
;
1406 atomic_or(ZFCP_STATUS_COMMON_OPEN
|
1407 ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
1408 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_BOXED
,
1410 /* check whether D_ID has changed during open */
1412 * FIXME: This check is not airtight, as the FCP channel does
1413 * not monitor closures of target port connections caused on
1414 * the remote side. Thus, they might miss out on invalidating
1415 * locally cached WWPNs (and other N_Port parameters) of gone
1416 * target ports. So, our heroic attempt to make things safe
1417 * could be undermined by 'open port' response data tagged with
1418 * obsolete WWPNs. Another reason to monitor potential
1419 * connection closures ourself at least (by interpreting
1420 * incoming ELS' and unsolicited status). It just crosses my
1421 * mind that one should be able to cross-check by means of
1422 * another GID_PN straight after a port has been opened.
1423 * Alternately, an ADISC/PDISC ELS should suffice, as well.
1425 plogi
= (struct fc_els_flogi
*) req
->qtcb
->bottom
.support
.els
;
1426 if (req
->qtcb
->bottom
.support
.els1_length
>=
1428 zfcp_fc_plogi_evaluate(port
, plogi
);
1430 case FSF_UNKNOWN_OP_SUBTYPE
:
1431 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1436 put_device(&port
->dev
);
1440 * zfcp_fsf_open_port - create and send open port request
1441 * @erp_action: pointer to struct zfcp_erp_action
1442 * Returns: 0 on success, error otherwise
1444 int zfcp_fsf_open_port(struct zfcp_erp_action
*erp_action
)
1446 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1447 struct zfcp_port
*port
= erp_action
->port
;
1448 struct zfcp_fsf_req
*req
;
1451 spin_lock_irq(&qdio
->req_q_lock
);
1452 if (zfcp_qdio_sbal_get(qdio
))
1455 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_OPEN_PORT_WITH_DID
,
1456 SBAL_SFLAGS0_TYPE_READ
,
1457 qdio
->adapter
->pool
.erp_req
);
1460 retval
= PTR_ERR(req
);
1464 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1465 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1467 req
->handler
= zfcp_fsf_open_port_handler
;
1468 hton24(req
->qtcb
->bottom
.support
.d_id
, port
->d_id
);
1470 req
->erp_action
= erp_action
;
1471 erp_action
->fsf_req_id
= req
->req_id
;
1472 get_device(&port
->dev
);
1474 zfcp_fsf_start_erp_timer(req
);
1475 retval
= zfcp_fsf_req_send(req
);
1477 zfcp_fsf_req_free(req
);
1478 erp_action
->fsf_req_id
= 0;
1479 put_device(&port
->dev
);
1482 spin_unlock_irq(&qdio
->req_q_lock
);
1486 static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req
*req
)
1488 struct zfcp_port
*port
= req
->data
;
1490 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1493 switch (req
->qtcb
->header
.fsf_status
) {
1494 case FSF_PORT_HANDLE_NOT_VALID
:
1495 zfcp_erp_adapter_reopen(port
->adapter
, 0, "fscph_1");
1496 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1498 case FSF_ADAPTER_STATUS_AVAILABLE
:
1501 zfcp_erp_clear_port_status(port
, ZFCP_STATUS_COMMON_OPEN
);
1507 * zfcp_fsf_close_port - create and send close port request
1508 * @erp_action: pointer to struct zfcp_erp_action
1509 * Returns: 0 on success, error otherwise
1511 int zfcp_fsf_close_port(struct zfcp_erp_action
*erp_action
)
1513 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1514 struct zfcp_fsf_req
*req
;
1517 spin_lock_irq(&qdio
->req_q_lock
);
1518 if (zfcp_qdio_sbal_get(qdio
))
1521 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_CLOSE_PORT
,
1522 SBAL_SFLAGS0_TYPE_READ
,
1523 qdio
->adapter
->pool
.erp_req
);
1526 retval
= PTR_ERR(req
);
1530 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1531 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1533 req
->handler
= zfcp_fsf_close_port_handler
;
1534 req
->data
= erp_action
->port
;
1535 req
->erp_action
= erp_action
;
1536 req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
1537 erp_action
->fsf_req_id
= req
->req_id
;
1539 zfcp_fsf_start_erp_timer(req
);
1540 retval
= zfcp_fsf_req_send(req
);
1542 zfcp_fsf_req_free(req
);
1543 erp_action
->fsf_req_id
= 0;
1546 spin_unlock_irq(&qdio
->req_q_lock
);
1550 static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req
*req
)
1552 struct zfcp_fc_wka_port
*wka_port
= req
->data
;
1553 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1555 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
1556 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
1560 switch (header
->fsf_status
) {
1561 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED
:
1562 dev_warn(&req
->adapter
->ccw_device
->dev
,
1563 "Opening WKA port 0x%x failed\n", wka_port
->d_id
);
1565 case FSF_ADAPTER_STATUS_AVAILABLE
:
1566 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1567 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
1570 wka_port
->handle
= header
->port_handle
;
1572 case FSF_PORT_ALREADY_OPEN
:
1573 wka_port
->status
= ZFCP_FC_WKA_PORT_ONLINE
;
1576 wake_up(&wka_port
->completion_wq
);
1580 * zfcp_fsf_open_wka_port - create and send open wka-port request
1581 * @wka_port: pointer to struct zfcp_fc_wka_port
1582 * Returns: 0 on success, error otherwise
1584 int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port
*wka_port
)
1586 struct zfcp_qdio
*qdio
= wka_port
->adapter
->qdio
;
1587 struct zfcp_fsf_req
*req
;
1590 spin_lock_irq(&qdio
->req_q_lock
);
1591 if (zfcp_qdio_sbal_get(qdio
))
1594 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_OPEN_PORT_WITH_DID
,
1595 SBAL_SFLAGS0_TYPE_READ
,
1596 qdio
->adapter
->pool
.erp_req
);
1599 retval
= PTR_ERR(req
);
1603 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1604 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1606 req
->handler
= zfcp_fsf_open_wka_port_handler
;
1607 hton24(req
->qtcb
->bottom
.support
.d_id
, wka_port
->d_id
);
1608 req
->data
= wka_port
;
1610 zfcp_fsf_start_timer(req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1611 retval
= zfcp_fsf_req_send(req
);
1613 zfcp_fsf_req_free(req
);
1615 spin_unlock_irq(&qdio
->req_q_lock
);
1617 zfcp_dbf_rec_run_wka("fsowp_1", wka_port
, req
->req_id
);
1621 static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req
*req
)
1623 struct zfcp_fc_wka_port
*wka_port
= req
->data
;
1625 if (req
->qtcb
->header
.fsf_status
== FSF_PORT_HANDLE_NOT_VALID
) {
1626 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1627 zfcp_erp_adapter_reopen(wka_port
->adapter
, 0, "fscwph1");
1630 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
1631 wake_up(&wka_port
->completion_wq
);
1635 * zfcp_fsf_close_wka_port - create and send close wka port request
1636 * @wka_port: WKA port to open
1637 * Returns: 0 on success, error otherwise
1639 int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port
*wka_port
)
1641 struct zfcp_qdio
*qdio
= wka_port
->adapter
->qdio
;
1642 struct zfcp_fsf_req
*req
;
1645 spin_lock_irq(&qdio
->req_q_lock
);
1646 if (zfcp_qdio_sbal_get(qdio
))
1649 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_CLOSE_PORT
,
1650 SBAL_SFLAGS0_TYPE_READ
,
1651 qdio
->adapter
->pool
.erp_req
);
1654 retval
= PTR_ERR(req
);
1658 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1659 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1661 req
->handler
= zfcp_fsf_close_wka_port_handler
;
1662 req
->data
= wka_port
;
1663 req
->qtcb
->header
.port_handle
= wka_port
->handle
;
1665 zfcp_fsf_start_timer(req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1666 retval
= zfcp_fsf_req_send(req
);
1668 zfcp_fsf_req_free(req
);
1670 spin_unlock_irq(&qdio
->req_q_lock
);
1672 zfcp_dbf_rec_run_wka("fscwp_1", wka_port
, req
->req_id
);
1676 static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req
*req
)
1678 struct zfcp_port
*port
= req
->data
;
1679 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1680 struct scsi_device
*sdev
;
1682 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1685 switch (header
->fsf_status
) {
1686 case FSF_PORT_HANDLE_NOT_VALID
:
1687 zfcp_erp_adapter_reopen(port
->adapter
, 0, "fscpph1");
1688 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1690 case FSF_PORT_BOXED
:
1691 /* can't use generic zfcp_erp_modify_port_status because
1692 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
1693 atomic_andnot(ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
1694 shost_for_each_device(sdev
, port
->adapter
->scsi_host
)
1695 if (sdev_to_zfcp(sdev
)->port
== port
)
1696 atomic_andnot(ZFCP_STATUS_COMMON_OPEN
,
1697 &sdev_to_zfcp(sdev
)->status
);
1698 zfcp_erp_set_port_status(port
, ZFCP_STATUS_COMMON_ACCESS_BOXED
);
1699 zfcp_erp_port_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
1701 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1703 case FSF_ADAPTER_STATUS_AVAILABLE
:
1704 switch (header
->fsf_status_qual
.word
[0]) {
1705 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1707 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1708 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1713 /* can't use generic zfcp_erp_modify_port_status because
1714 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
1716 atomic_andnot(ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
1717 shost_for_each_device(sdev
, port
->adapter
->scsi_host
)
1718 if (sdev_to_zfcp(sdev
)->port
== port
)
1719 atomic_andnot(ZFCP_STATUS_COMMON_OPEN
,
1720 &sdev_to_zfcp(sdev
)->status
);
1726 * zfcp_fsf_close_physical_port - close physical port
1727 * @erp_action: pointer to struct zfcp_erp_action
1728 * Returns: 0 on success
1730 int zfcp_fsf_close_physical_port(struct zfcp_erp_action
*erp_action
)
1732 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1733 struct zfcp_fsf_req
*req
;
1736 spin_lock_irq(&qdio
->req_q_lock
);
1737 if (zfcp_qdio_sbal_get(qdio
))
1740 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_CLOSE_PHYSICAL_PORT
,
1741 SBAL_SFLAGS0_TYPE_READ
,
1742 qdio
->adapter
->pool
.erp_req
);
1745 retval
= PTR_ERR(req
);
1749 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1750 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1752 req
->data
= erp_action
->port
;
1753 req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
1754 req
->erp_action
= erp_action
;
1755 req
->handler
= zfcp_fsf_close_physical_port_handler
;
1756 erp_action
->fsf_req_id
= req
->req_id
;
1758 zfcp_fsf_start_erp_timer(req
);
1759 retval
= zfcp_fsf_req_send(req
);
1761 zfcp_fsf_req_free(req
);
1762 erp_action
->fsf_req_id
= 0;
1765 spin_unlock_irq(&qdio
->req_q_lock
);
1769 static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req
*req
)
1771 struct zfcp_adapter
*adapter
= req
->adapter
;
1772 struct scsi_device
*sdev
= req
->data
;
1773 struct zfcp_scsi_dev
*zfcp_sdev
;
1774 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
1775 union fsf_status_qual
*qual
= &header
->fsf_status_qual
;
1777 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1780 zfcp_sdev
= sdev_to_zfcp(sdev
);
1782 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED
|
1783 ZFCP_STATUS_COMMON_ACCESS_BOXED
,
1784 &zfcp_sdev
->status
);
1786 switch (header
->fsf_status
) {
1788 case FSF_PORT_HANDLE_NOT_VALID
:
1789 zfcp_erp_adapter_reopen(adapter
, 0, "fsouh_1");
1791 case FSF_LUN_ALREADY_OPEN
:
1793 case FSF_PORT_BOXED
:
1794 zfcp_erp_set_port_status(zfcp_sdev
->port
,
1795 ZFCP_STATUS_COMMON_ACCESS_BOXED
);
1796 zfcp_erp_port_reopen(zfcp_sdev
->port
,
1797 ZFCP_STATUS_COMMON_ERP_FAILED
, "fsouh_2");
1798 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1800 case FSF_LUN_SHARING_VIOLATION
:
1802 dev_warn(&zfcp_sdev
->port
->adapter
->ccw_device
->dev
,
1803 "LUN 0x%Lx on port 0x%Lx is already in "
1804 "use by CSS%d, MIF Image ID %x\n",
1805 zfcp_scsi_dev_lun(sdev
),
1806 (unsigned long long)zfcp_sdev
->port
->wwpn
,
1807 qual
->fsf_queue_designator
.cssid
,
1808 qual
->fsf_queue_designator
.hla
);
1809 zfcp_erp_set_lun_status(sdev
,
1810 ZFCP_STATUS_COMMON_ERP_FAILED
|
1811 ZFCP_STATUS_COMMON_ACCESS_DENIED
);
1812 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1814 case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED
:
1815 dev_warn(&adapter
->ccw_device
->dev
,
1816 "No handle is available for LUN "
1817 "0x%016Lx on port 0x%016Lx\n",
1818 (unsigned long long)zfcp_scsi_dev_lun(sdev
),
1819 (unsigned long long)zfcp_sdev
->port
->wwpn
);
1820 zfcp_erp_set_lun_status(sdev
, ZFCP_STATUS_COMMON_ERP_FAILED
);
1822 case FSF_INVALID_COMMAND_OPTION
:
1823 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1825 case FSF_ADAPTER_STATUS_AVAILABLE
:
1826 switch (header
->fsf_status_qual
.word
[0]) {
1827 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1828 zfcp_fc_test_link(zfcp_sdev
->port
);
1830 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1831 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1837 zfcp_sdev
->lun_handle
= header
->lun_handle
;
1838 atomic_or(ZFCP_STATUS_COMMON_OPEN
, &zfcp_sdev
->status
);
1844 * zfcp_fsf_open_lun - open LUN
1845 * @erp_action: pointer to struct zfcp_erp_action
1846 * Returns: 0 on success, error otherwise
1848 int zfcp_fsf_open_lun(struct zfcp_erp_action
*erp_action
)
1850 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
1851 struct zfcp_qdio
*qdio
= adapter
->qdio
;
1852 struct zfcp_fsf_req
*req
;
1855 spin_lock_irq(&qdio
->req_q_lock
);
1856 if (zfcp_qdio_sbal_get(qdio
))
1859 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_OPEN_LUN
,
1860 SBAL_SFLAGS0_TYPE_READ
,
1861 adapter
->pool
.erp_req
);
1864 retval
= PTR_ERR(req
);
1868 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1869 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1871 req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
1872 req
->qtcb
->bottom
.support
.fcp_lun
= zfcp_scsi_dev_lun(erp_action
->sdev
);
1873 req
->handler
= zfcp_fsf_open_lun_handler
;
1874 req
->data
= erp_action
->sdev
;
1875 req
->erp_action
= erp_action
;
1876 erp_action
->fsf_req_id
= req
->req_id
;
1878 if (!(adapter
->connection_features
& FSF_FEATURE_NPIV_MODE
))
1879 req
->qtcb
->bottom
.support
.option
= FSF_OPEN_LUN_SUPPRESS_BOXING
;
1881 zfcp_fsf_start_erp_timer(req
);
1882 retval
= zfcp_fsf_req_send(req
);
1884 zfcp_fsf_req_free(req
);
1885 erp_action
->fsf_req_id
= 0;
1888 spin_unlock_irq(&qdio
->req_q_lock
);
1892 static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req
*req
)
1894 struct scsi_device
*sdev
= req
->data
;
1895 struct zfcp_scsi_dev
*zfcp_sdev
;
1897 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1900 zfcp_sdev
= sdev_to_zfcp(sdev
);
1902 switch (req
->qtcb
->header
.fsf_status
) {
1903 case FSF_PORT_HANDLE_NOT_VALID
:
1904 zfcp_erp_adapter_reopen(zfcp_sdev
->port
->adapter
, 0, "fscuh_1");
1905 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1907 case FSF_LUN_HANDLE_NOT_VALID
:
1908 zfcp_erp_port_reopen(zfcp_sdev
->port
, 0, "fscuh_2");
1909 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1911 case FSF_PORT_BOXED
:
1912 zfcp_erp_set_port_status(zfcp_sdev
->port
,
1913 ZFCP_STATUS_COMMON_ACCESS_BOXED
);
1914 zfcp_erp_port_reopen(zfcp_sdev
->port
,
1915 ZFCP_STATUS_COMMON_ERP_FAILED
, "fscuh_3");
1916 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1918 case FSF_ADAPTER_STATUS_AVAILABLE
:
1919 switch (req
->qtcb
->header
.fsf_status_qual
.word
[0]) {
1920 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1921 zfcp_fc_test_link(zfcp_sdev
->port
);
1923 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1924 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1929 atomic_andnot(ZFCP_STATUS_COMMON_OPEN
, &zfcp_sdev
->status
);
1935 * zfcp_fsf_close_LUN - close LUN
1936 * @erp_action: pointer to erp_action triggering the "close LUN"
1937 * Returns: 0 on success, error otherwise
1939 int zfcp_fsf_close_lun(struct zfcp_erp_action
*erp_action
)
1941 struct zfcp_qdio
*qdio
= erp_action
->adapter
->qdio
;
1942 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(erp_action
->sdev
);
1943 struct zfcp_fsf_req
*req
;
1946 spin_lock_irq(&qdio
->req_q_lock
);
1947 if (zfcp_qdio_sbal_get(qdio
))
1950 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_CLOSE_LUN
,
1951 SBAL_SFLAGS0_TYPE_READ
,
1952 qdio
->adapter
->pool
.erp_req
);
1955 retval
= PTR_ERR(req
);
1959 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
1960 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
1962 req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
1963 req
->qtcb
->header
.lun_handle
= zfcp_sdev
->lun_handle
;
1964 req
->handler
= zfcp_fsf_close_lun_handler
;
1965 req
->data
= erp_action
->sdev
;
1966 req
->erp_action
= erp_action
;
1967 erp_action
->fsf_req_id
= req
->req_id
;
1969 zfcp_fsf_start_erp_timer(req
);
1970 retval
= zfcp_fsf_req_send(req
);
1972 zfcp_fsf_req_free(req
);
1973 erp_action
->fsf_req_id
= 0;
1976 spin_unlock_irq(&qdio
->req_q_lock
);
1980 static void zfcp_fsf_update_lat(struct fsf_latency_record
*lat_rec
, u32 lat
)
1982 lat_rec
->sum
+= lat
;
1983 lat_rec
->min
= min(lat_rec
->min
, lat
);
1984 lat_rec
->max
= max(lat_rec
->max
, lat
);
1987 static void zfcp_fsf_req_trace(struct zfcp_fsf_req
*req
, struct scsi_cmnd
*scsi
)
1989 struct fsf_qual_latency_info
*lat_in
;
1990 struct latency_cont
*lat
= NULL
;
1991 struct zfcp_scsi_dev
*zfcp_sdev
;
1992 struct zfcp_blk_drv_data blktrc
;
1993 int ticks
= req
->adapter
->timer_ticks
;
1995 lat_in
= &req
->qtcb
->prefix
.prot_status_qual
.latency_info
;
1998 blktrc
.magic
= ZFCP_BLK_DRV_DATA_MAGIC
;
1999 if (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
2000 blktrc
.flags
|= ZFCP_BLK_REQ_ERROR
;
2001 blktrc
.inb_usage
= 0;
2002 blktrc
.outb_usage
= req
->qdio_req
.qdio_outb_usage
;
2004 if (req
->adapter
->adapter_features
& FSF_FEATURE_MEASUREMENT_DATA
&&
2005 !(req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)) {
2006 zfcp_sdev
= sdev_to_zfcp(scsi
->device
);
2007 blktrc
.flags
|= ZFCP_BLK_LAT_VALID
;
2008 blktrc
.channel_lat
= lat_in
->channel_lat
* ticks
;
2009 blktrc
.fabric_lat
= lat_in
->fabric_lat
* ticks
;
2011 switch (req
->qtcb
->bottom
.io
.data_direction
) {
2012 case FSF_DATADIR_DIF_READ_STRIP
:
2013 case FSF_DATADIR_DIF_READ_CONVERT
:
2014 case FSF_DATADIR_READ
:
2015 lat
= &zfcp_sdev
->latencies
.read
;
2017 case FSF_DATADIR_DIF_WRITE_INSERT
:
2018 case FSF_DATADIR_DIF_WRITE_CONVERT
:
2019 case FSF_DATADIR_WRITE
:
2020 lat
= &zfcp_sdev
->latencies
.write
;
2022 case FSF_DATADIR_CMND
:
2023 lat
= &zfcp_sdev
->latencies
.cmd
;
2028 spin_lock(&zfcp_sdev
->latencies
.lock
);
2029 zfcp_fsf_update_lat(&lat
->channel
, lat_in
->channel_lat
);
2030 zfcp_fsf_update_lat(&lat
->fabric
, lat_in
->fabric_lat
);
2032 spin_unlock(&zfcp_sdev
->latencies
.lock
);
2036 blk_add_driver_data(scsi
->request
->q
, scsi
->request
, &blktrc
,
2040 static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req
*req
)
2042 struct scsi_cmnd
*scmnd
= req
->data
;
2043 struct scsi_device
*sdev
= scmnd
->device
;
2044 struct zfcp_scsi_dev
*zfcp_sdev
;
2045 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
2047 if (unlikely(req
->status
& ZFCP_STATUS_FSFREQ_ERROR
))
2050 zfcp_sdev
= sdev_to_zfcp(sdev
);
2052 switch (header
->fsf_status
) {
2053 case FSF_HANDLE_MISMATCH
:
2054 case FSF_PORT_HANDLE_NOT_VALID
:
2055 zfcp_erp_adapter_reopen(zfcp_sdev
->port
->adapter
, 0, "fssfch1");
2056 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2058 case FSF_FCPLUN_NOT_VALID
:
2059 case FSF_LUN_HANDLE_NOT_VALID
:
2060 zfcp_erp_port_reopen(zfcp_sdev
->port
, 0, "fssfch2");
2061 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2063 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
2064 zfcp_fsf_class_not_supp(req
);
2066 case FSF_DIRECTION_INDICATOR_NOT_VALID
:
2067 dev_err(&req
->adapter
->ccw_device
->dev
,
2068 "Incorrect direction %d, LUN 0x%016Lx on port "
2069 "0x%016Lx closed\n",
2070 req
->qtcb
->bottom
.io
.data_direction
,
2071 (unsigned long long)zfcp_scsi_dev_lun(sdev
),
2072 (unsigned long long)zfcp_sdev
->port
->wwpn
);
2073 zfcp_erp_adapter_shutdown(zfcp_sdev
->port
->adapter
, 0,
2075 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2077 case FSF_CMND_LENGTH_NOT_VALID
:
2078 dev_err(&req
->adapter
->ccw_device
->dev
,
2079 "Incorrect CDB length %d, LUN 0x%016Lx on "
2080 "port 0x%016Lx closed\n",
2081 req
->qtcb
->bottom
.io
.fcp_cmnd_length
,
2082 (unsigned long long)zfcp_scsi_dev_lun(sdev
),
2083 (unsigned long long)zfcp_sdev
->port
->wwpn
);
2084 zfcp_erp_adapter_shutdown(zfcp_sdev
->port
->adapter
, 0,
2086 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2088 case FSF_PORT_BOXED
:
2089 zfcp_erp_set_port_status(zfcp_sdev
->port
,
2090 ZFCP_STATUS_COMMON_ACCESS_BOXED
);
2091 zfcp_erp_port_reopen(zfcp_sdev
->port
,
2092 ZFCP_STATUS_COMMON_ERP_FAILED
, "fssfch5");
2093 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2096 zfcp_erp_set_lun_status(sdev
, ZFCP_STATUS_COMMON_ACCESS_BOXED
);
2097 zfcp_erp_lun_reopen(sdev
, ZFCP_STATUS_COMMON_ERP_FAILED
,
2099 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2101 case FSF_ADAPTER_STATUS_AVAILABLE
:
2102 if (header
->fsf_status_qual
.word
[0] ==
2103 FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
)
2104 zfcp_fc_test_link(zfcp_sdev
->port
);
2105 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2110 static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req
*req
)
2112 struct scsi_cmnd
*scpnt
;
2113 struct fcp_resp_with_ext
*fcp_rsp
;
2114 unsigned long flags
;
2116 read_lock_irqsave(&req
->adapter
->abort_lock
, flags
);
2119 if (unlikely(!scpnt
)) {
2120 read_unlock_irqrestore(&req
->adapter
->abort_lock
, flags
);
2124 zfcp_fsf_fcp_handler_common(req
);
2126 if (unlikely(req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)) {
2127 set_host_byte(scpnt
, DID_TRANSPORT_DISRUPTED
);
2128 goto skip_fsfstatus
;
2131 switch (req
->qtcb
->header
.fsf_status
) {
2132 case FSF_INCONSISTENT_PROT_DATA
:
2133 case FSF_INVALID_PROT_PARM
:
2134 set_host_byte(scpnt
, DID_ERROR
);
2135 goto skip_fsfstatus
;
2136 case FSF_BLOCK_GUARD_CHECK_FAILURE
:
2137 zfcp_scsi_dif_sense_error(scpnt
, 0x1);
2138 goto skip_fsfstatus
;
2139 case FSF_APP_TAG_CHECK_FAILURE
:
2140 zfcp_scsi_dif_sense_error(scpnt
, 0x2);
2141 goto skip_fsfstatus
;
2142 case FSF_REF_TAG_CHECK_FAILURE
:
2143 zfcp_scsi_dif_sense_error(scpnt
, 0x3);
2144 goto skip_fsfstatus
;
2146 BUILD_BUG_ON(sizeof(struct fcp_resp_with_ext
) > FSF_FCP_RSP_SIZE
);
2147 fcp_rsp
= &req
->qtcb
->bottom
.io
.fcp_rsp
.iu
;
2148 zfcp_fc_eval_fcp_rsp(fcp_rsp
, scpnt
);
2151 zfcp_fsf_req_trace(req
, scpnt
);
2152 zfcp_dbf_scsi_result(scpnt
, req
);
2154 scpnt
->host_scribble
= NULL
;
2155 (scpnt
->scsi_done
) (scpnt
);
2157 * We must hold this lock until scsi_done has been called.
2158 * Otherwise we may call scsi_done after abort regarding this
2159 * command has completed.
2160 * Note: scsi_done must not block!
2162 read_unlock_irqrestore(&req
->adapter
->abort_lock
, flags
);
2165 static int zfcp_fsf_set_data_dir(struct scsi_cmnd
*scsi_cmnd
, u32
*data_dir
)
2167 switch (scsi_get_prot_op(scsi_cmnd
)) {
2168 case SCSI_PROT_NORMAL
:
2169 switch (scsi_cmnd
->sc_data_direction
) {
2171 *data_dir
= FSF_DATADIR_CMND
;
2173 case DMA_FROM_DEVICE
:
2174 *data_dir
= FSF_DATADIR_READ
;
2177 *data_dir
= FSF_DATADIR_WRITE
;
2179 case DMA_BIDIRECTIONAL
:
2184 case SCSI_PROT_READ_STRIP
:
2185 *data_dir
= FSF_DATADIR_DIF_READ_STRIP
;
2187 case SCSI_PROT_WRITE_INSERT
:
2188 *data_dir
= FSF_DATADIR_DIF_WRITE_INSERT
;
2190 case SCSI_PROT_READ_PASS
:
2191 *data_dir
= FSF_DATADIR_DIF_READ_CONVERT
;
2193 case SCSI_PROT_WRITE_PASS
:
2194 *data_dir
= FSF_DATADIR_DIF_WRITE_CONVERT
;
2204 * zfcp_fsf_fcp_cmnd - initiate an FCP command (for a SCSI command)
2205 * @scsi_cmnd: scsi command to be sent
2207 int zfcp_fsf_fcp_cmnd(struct scsi_cmnd
*scsi_cmnd
)
2209 struct zfcp_fsf_req
*req
;
2210 struct fcp_cmnd
*fcp_cmnd
;
2211 u8 sbtype
= SBAL_SFLAGS0_TYPE_READ
;
2213 struct scsi_device
*sdev
= scsi_cmnd
->device
;
2214 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(sdev
);
2215 struct zfcp_adapter
*adapter
= zfcp_sdev
->port
->adapter
;
2216 struct zfcp_qdio
*qdio
= adapter
->qdio
;
2217 struct fsf_qtcb_bottom_io
*io
;
2218 unsigned long flags
;
2220 if (unlikely(!(atomic_read(&zfcp_sdev
->status
) &
2221 ZFCP_STATUS_COMMON_UNBLOCKED
)))
2224 spin_lock_irqsave(&qdio
->req_q_lock
, flags
);
2225 if (atomic_read(&qdio
->req_q_free
) <= 0) {
2226 atomic_inc(&qdio
->req_q_full
);
2230 if (scsi_cmnd
->sc_data_direction
== DMA_TO_DEVICE
)
2231 sbtype
= SBAL_SFLAGS0_TYPE_WRITE
;
2233 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_FCP_CMND
,
2234 sbtype
, adapter
->pool
.scsi_req
);
2237 retval
= PTR_ERR(req
);
2241 scsi_cmnd
->host_scribble
= (unsigned char *) req
->req_id
;
2243 io
= &req
->qtcb
->bottom
.io
;
2244 req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
2245 req
->data
= scsi_cmnd
;
2246 req
->handler
= zfcp_fsf_fcp_cmnd_handler
;
2247 req
->qtcb
->header
.lun_handle
= zfcp_sdev
->lun_handle
;
2248 req
->qtcb
->header
.port_handle
= zfcp_sdev
->port
->handle
;
2249 io
->service_class
= FSF_CLASS_3
;
2250 io
->fcp_cmnd_length
= FCP_CMND_LEN
;
2252 if (scsi_get_prot_op(scsi_cmnd
) != SCSI_PROT_NORMAL
) {
2253 io
->data_block_length
= scsi_cmnd
->device
->sector_size
;
2254 io
->ref_tag_value
= scsi_get_lba(scsi_cmnd
) & 0xFFFFFFFF;
2257 if (zfcp_fsf_set_data_dir(scsi_cmnd
, &io
->data_direction
))
2258 goto failed_scsi_cmnd
;
2260 BUILD_BUG_ON(sizeof(struct fcp_cmnd
) > FSF_FCP_CMND_SIZE
);
2261 fcp_cmnd
= &req
->qtcb
->bottom
.io
.fcp_cmnd
.iu
;
2262 zfcp_fc_scsi_to_fcp(fcp_cmnd
, scsi_cmnd
, 0);
2264 if ((scsi_get_prot_op(scsi_cmnd
) != SCSI_PROT_NORMAL
) &&
2265 scsi_prot_sg_count(scsi_cmnd
)) {
2266 zfcp_qdio_set_data_div(qdio
, &req
->qdio_req
,
2267 scsi_prot_sg_count(scsi_cmnd
));
2268 retval
= zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
,
2269 scsi_prot_sglist(scsi_cmnd
));
2271 goto failed_scsi_cmnd
;
2272 io
->prot_data_length
= zfcp_qdio_real_bytes(
2273 scsi_prot_sglist(scsi_cmnd
));
2276 retval
= zfcp_qdio_sbals_from_sg(qdio
, &req
->qdio_req
,
2277 scsi_sglist(scsi_cmnd
));
2278 if (unlikely(retval
))
2279 goto failed_scsi_cmnd
;
2281 zfcp_qdio_set_sbale_last(adapter
->qdio
, &req
->qdio_req
);
2282 if (zfcp_adapter_multi_buffer_active(adapter
))
2283 zfcp_qdio_set_scount(qdio
, &req
->qdio_req
);
2285 retval
= zfcp_fsf_req_send(req
);
2286 if (unlikely(retval
))
2287 goto failed_scsi_cmnd
;
2292 zfcp_fsf_req_free(req
);
2293 scsi_cmnd
->host_scribble
= NULL
;
2295 spin_unlock_irqrestore(&qdio
->req_q_lock
, flags
);
2299 static void zfcp_fsf_fcp_task_mgmt_handler(struct zfcp_fsf_req
*req
)
2301 struct fcp_resp_with_ext
*fcp_rsp
;
2302 struct fcp_resp_rsp_info
*rsp_info
;
2304 zfcp_fsf_fcp_handler_common(req
);
2306 fcp_rsp
= &req
->qtcb
->bottom
.io
.fcp_rsp
.iu
;
2307 rsp_info
= (struct fcp_resp_rsp_info
*) &fcp_rsp
[1];
2309 if ((rsp_info
->rsp_code
!= FCP_TMF_CMPL
) ||
2310 (req
->status
& ZFCP_STATUS_FSFREQ_ERROR
))
2311 req
->status
|= ZFCP_STATUS_FSFREQ_TMFUNCFAILED
;
2315 * zfcp_fsf_fcp_task_mgmt - send SCSI task management command
2316 * @scmnd: SCSI command to send the task management command for
2317 * @tm_flags: unsigned byte for task management flags
2318 * Returns: on success pointer to struct fsf_req, NULL otherwise
2320 struct zfcp_fsf_req
*zfcp_fsf_fcp_task_mgmt(struct scsi_cmnd
*scmnd
,
2323 struct zfcp_fsf_req
*req
= NULL
;
2324 struct fcp_cmnd
*fcp_cmnd
;
2325 struct zfcp_scsi_dev
*zfcp_sdev
= sdev_to_zfcp(scmnd
->device
);
2326 struct zfcp_qdio
*qdio
= zfcp_sdev
->port
->adapter
->qdio
;
2328 if (unlikely(!(atomic_read(&zfcp_sdev
->status
) &
2329 ZFCP_STATUS_COMMON_UNBLOCKED
)))
2332 spin_lock_irq(&qdio
->req_q_lock
);
2333 if (zfcp_qdio_sbal_get(qdio
))
2336 req
= zfcp_fsf_req_create(qdio
, FSF_QTCB_FCP_CMND
,
2337 SBAL_SFLAGS0_TYPE_WRITE
,
2338 qdio
->adapter
->pool
.scsi_req
);
2346 req
->handler
= zfcp_fsf_fcp_task_mgmt_handler
;
2347 req
->qtcb
->header
.lun_handle
= zfcp_sdev
->lun_handle
;
2348 req
->qtcb
->header
.port_handle
= zfcp_sdev
->port
->handle
;
2349 req
->qtcb
->bottom
.io
.data_direction
= FSF_DATADIR_CMND
;
2350 req
->qtcb
->bottom
.io
.service_class
= FSF_CLASS_3
;
2351 req
->qtcb
->bottom
.io
.fcp_cmnd_length
= FCP_CMND_LEN
;
2353 zfcp_qdio_set_sbale_last(qdio
, &req
->qdio_req
);
2355 fcp_cmnd
= &req
->qtcb
->bottom
.io
.fcp_cmnd
.iu
;
2356 zfcp_fc_scsi_to_fcp(fcp_cmnd
, scmnd
, tm_flags
);
2358 zfcp_fsf_start_timer(req
, ZFCP_SCSI_ER_TIMEOUT
);
2359 if (!zfcp_fsf_req_send(req
))
2362 zfcp_fsf_req_free(req
);
2365 spin_unlock_irq(&qdio
->req_q_lock
);
2370 * zfcp_fsf_reqid_check - validate req_id contained in SBAL returned by QDIO
2371 * @adapter: pointer to struct zfcp_adapter
2372 * @sbal_idx: response queue index of SBAL to be processed
2374 void zfcp_fsf_reqid_check(struct zfcp_qdio
*qdio
, int sbal_idx
)
2376 struct zfcp_adapter
*adapter
= qdio
->adapter
;
2377 struct qdio_buffer
*sbal
= qdio
->res_q
[sbal_idx
];
2378 struct qdio_buffer_element
*sbale
;
2379 struct zfcp_fsf_req
*fsf_req
;
2380 unsigned long req_id
;
2383 for (idx
= 0; idx
< QDIO_MAX_ELEMENTS_PER_BUFFER
; idx
++) {
2385 sbale
= &sbal
->element
[idx
];
2386 req_id
= (unsigned long) sbale
->addr
;
2387 fsf_req
= zfcp_reqlist_find_rm(adapter
->req_list
, req_id
);
2391 * Unknown request means that we have potentially memory
2392 * corruption and must stop the machine immediately.
2394 zfcp_qdio_siosl(adapter
);
2395 panic("error: unknown req_id (%lx) on adapter %s.\n",
2396 req_id
, dev_name(&adapter
->ccw_device
->dev
));
2399 fsf_req
->qdio_req
.sbal_response
= sbal_idx
;
2400 zfcp_fsf_req_complete(fsf_req
);
2402 if (likely(sbale
->eflags
& SBAL_EFLAGS_LAST_ENTRY
))