4 * Implementation of FSF commands.
6 * Copyright IBM Corporation 2002, 2008
11 static int zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req
*);
12 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req
*);
13 static int zfcp_fsf_open_port_handler(struct zfcp_fsf_req
*);
14 static int zfcp_fsf_close_port_handler(struct zfcp_fsf_req
*);
15 static int zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req
*);
16 static int zfcp_fsf_open_unit_handler(struct zfcp_fsf_req
*);
17 static int zfcp_fsf_close_unit_handler(struct zfcp_fsf_req
*);
18 static int zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req
*);
19 static int zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req
*);
20 static int zfcp_fsf_send_fcp_command_task_management_handler(
21 struct zfcp_fsf_req
*);
22 static int zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req
*);
23 static int zfcp_fsf_status_read_handler(struct zfcp_fsf_req
*);
24 static int zfcp_fsf_send_ct_handler(struct zfcp_fsf_req
*);
25 static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req
*);
26 static void zfcp_fsf_control_file_handler(struct zfcp_fsf_req
*);
27 static inline int zfcp_fsf_req_sbal_check(
28 unsigned long *, struct zfcp_qdio_queue
*, int);
29 static inline int zfcp_use_one_sbal(
30 struct scatterlist
*, int, struct scatterlist
*, int);
31 static struct zfcp_fsf_req
*zfcp_fsf_req_alloc(mempool_t
*, int);
32 static int zfcp_fsf_req_send(struct zfcp_fsf_req
*);
33 static int zfcp_fsf_protstatus_eval(struct zfcp_fsf_req
*);
34 static int zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req
*);
35 static int zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req
*);
36 static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req
*, u8
,
37 struct fsf_link_down_info
*);
38 static int zfcp_fsf_req_dispatch(struct zfcp_fsf_req
*);
40 /* association between FSF command and FSF QTCB type */
41 static u32 fsf_qtcb_type
[] = {
42 [FSF_QTCB_FCP_CMND
] = FSF_IO_COMMAND
,
43 [FSF_QTCB_ABORT_FCP_CMND
] = FSF_SUPPORT_COMMAND
,
44 [FSF_QTCB_OPEN_PORT_WITH_DID
] = FSF_SUPPORT_COMMAND
,
45 [FSF_QTCB_OPEN_LUN
] = FSF_SUPPORT_COMMAND
,
46 [FSF_QTCB_CLOSE_LUN
] = FSF_SUPPORT_COMMAND
,
47 [FSF_QTCB_CLOSE_PORT
] = FSF_SUPPORT_COMMAND
,
48 [FSF_QTCB_CLOSE_PHYSICAL_PORT
] = FSF_SUPPORT_COMMAND
,
49 [FSF_QTCB_SEND_ELS
] = FSF_SUPPORT_COMMAND
,
50 [FSF_QTCB_SEND_GENERIC
] = FSF_SUPPORT_COMMAND
,
51 [FSF_QTCB_EXCHANGE_CONFIG_DATA
] = FSF_CONFIG_COMMAND
,
52 [FSF_QTCB_EXCHANGE_PORT_DATA
] = FSF_PORT_COMMAND
,
53 [FSF_QTCB_DOWNLOAD_CONTROL_FILE
] = FSF_SUPPORT_COMMAND
,
54 [FSF_QTCB_UPLOAD_CONTROL_FILE
] = FSF_SUPPORT_COMMAND
57 static const char zfcp_act_subtable_type
[5][8] = {
58 "unknown", "OS", "WWPN", "DID", "LUN"
61 static void zfcp_act_eval_err(struct zfcp_adapter
*adapter
, u32 table
)
63 u16 subtable
= (table
& 0xffff0000) >> 16;
64 u16 rule
= table
& 0xffff;
67 subtable
< ARRAY_SIZE(zfcp_act_subtable_type
)) {
68 dev_warn(&adapter
->ccw_device
->dev
,
69 "Access denied in subtable %s, rule %d.\n",
70 zfcp_act_subtable_type
[subtable
], rule
);
74 static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req
*req
,
75 struct zfcp_port
*port
)
77 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
78 dev_warn(&req
->adapter
->ccw_device
->dev
,
79 "Access denied, cannot send command to port 0x%016Lx.\n",
81 zfcp_act_eval_err(req
->adapter
, header
->fsf_status_qual
.halfword
[0]);
82 zfcp_act_eval_err(req
->adapter
, header
->fsf_status_qual
.halfword
[1]);
83 zfcp_erp_port_access_denied(port
, 55, req
);
84 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
87 static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req
*req
,
88 struct zfcp_unit
*unit
)
90 struct fsf_qtcb_header
*header
= &req
->qtcb
->header
;
91 dev_warn(&req
->adapter
->ccw_device
->dev
,
92 "Access denied for unit 0x%016Lx on port 0x%016Lx.\n",
93 unit
->fcp_lun
, unit
->port
->wwpn
);
94 zfcp_act_eval_err(req
->adapter
, header
->fsf_status_qual
.halfword
[0]);
95 zfcp_act_eval_err(req
->adapter
, header
->fsf_status_qual
.halfword
[1]);
96 zfcp_erp_unit_access_denied(unit
, 59, req
);
97 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
100 static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req
*req
)
102 dev_err(&req
->adapter
->ccw_device
->dev
,
103 "Required FC class not supported by adapter, "
104 "shutting down adapter.\n");
105 zfcp_erp_adapter_shutdown(req
->adapter
, 0, 123, req
);
106 req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
109 /****************************************************************/
110 /*************** FSF related Functions *************************/
111 /****************************************************************/
114 * function: zfcp_fsf_req_alloc
116 * purpose: Obtains an fsf_req and potentially a qtcb (for all but
117 * unsolicited requests) via helper functions
118 * Does some initial fsf request set-up.
120 * returns: pointer to allocated fsf_req if successfull
126 static struct zfcp_fsf_req
*
127 zfcp_fsf_req_alloc(mempool_t
*pool
, int req_flags
)
131 struct zfcp_fsf_req
*fsf_req
= NULL
;
133 if (req_flags
& ZFCP_REQ_NO_QTCB
)
134 size
= sizeof(struct zfcp_fsf_req
);
136 size
= sizeof(struct zfcp_fsf_req_qtcb
);
139 ptr
= mempool_alloc(pool
, GFP_ATOMIC
);
141 if (req_flags
& ZFCP_REQ_NO_QTCB
)
142 ptr
= kmalloc(size
, GFP_ATOMIC
);
144 ptr
= kmem_cache_alloc(zfcp_data
.fsf_req_qtcb_cache
,
151 memset(ptr
, 0, size
);
153 if (req_flags
& ZFCP_REQ_NO_QTCB
) {
154 fsf_req
= (struct zfcp_fsf_req
*) ptr
;
156 fsf_req
= &((struct zfcp_fsf_req_qtcb
*) ptr
)->fsf_req
;
157 fsf_req
->qtcb
= &((struct zfcp_fsf_req_qtcb
*) ptr
)->qtcb
;
160 fsf_req
->pool
= pool
;
167 * function: zfcp_fsf_req_free
169 * purpose: Frees the memory of an fsf_req (and potentially a qtcb) or
170 * returns it into the pool via helper functions.
177 zfcp_fsf_req_free(struct zfcp_fsf_req
*fsf_req
)
179 if (likely(fsf_req
->pool
)) {
180 mempool_free(fsf_req
, fsf_req
->pool
);
185 kmem_cache_free(zfcp_data
.fsf_req_qtcb_cache
, fsf_req
);
193 * Never ever call this without shutting down the adapter first.
194 * Otherwise the adapter would continue using and corrupting s390 storage.
195 * Included BUG_ON() call to ensure this is done.
196 * ERP is supposed to be the only user of this function.
198 void zfcp_fsf_req_dismiss_all(struct zfcp_adapter
*adapter
)
200 struct zfcp_fsf_req
*fsf_req
, *tmp
;
202 LIST_HEAD(remove_queue
);
205 BUG_ON(atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP
, &adapter
->status
));
206 spin_lock_irqsave(&adapter
->req_list_lock
, flags
);
207 for (i
= 0; i
< REQUEST_LIST_SIZE
; i
++)
208 list_splice_init(&adapter
->req_list
[i
], &remove_queue
);
209 spin_unlock_irqrestore(&adapter
->req_list_lock
, flags
);
211 list_for_each_entry_safe(fsf_req
, tmp
, &remove_queue
, list
) {
212 list_del(&fsf_req
->list
);
213 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_DISMISSED
;
214 zfcp_fsf_req_complete(fsf_req
);
219 * function: zfcp_fsf_req_complete
221 * purpose: Updates active counts and timers for openfcp-reqs
222 * May cleanup request after req_eval returns
224 * returns: 0 - success
230 zfcp_fsf_req_complete(struct zfcp_fsf_req
*fsf_req
)
235 if (unlikely(fsf_req
->fsf_command
== FSF_QTCB_UNSOLICITED_STATUS
)) {
237 * Note: all cleanup handling is done in the callchain of
238 * the function call-chain below.
240 zfcp_fsf_status_read_handler(fsf_req
);
243 del_timer(&fsf_req
->timer
);
244 zfcp_fsf_protstatus_eval(fsf_req
);
248 * fsf_req may be deleted due to waking up functions, so
249 * cleanup is saved here and used later
251 if (likely(fsf_req
->status
& ZFCP_STATUS_FSFREQ_CLEANUP
))
256 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_COMPLETED
;
258 /* cleanup request if requested by initiator */
259 if (likely(cleanup
)) {
261 * lock must not be held here since it will be
262 * grabed by the called routine, too
264 zfcp_fsf_req_free(fsf_req
);
266 /* notify initiator waiting for the requests completion */
268 * FIXME: Race! We must not access fsf_req here as it might have been
269 * cleaned up already due to the set ZFCP_STATUS_FSFREQ_COMPLETED
270 * flag. It's an improbable case. But, we have the same paranoia for
271 * the cleanup flag already.
272 * Might better be handled using complete()?
273 * (setting the flag and doing wakeup ought to be atomic
274 * with regard to checking the flag as long as waitqueue is
275 * part of the to be released structure)
277 wake_up(&fsf_req
->completion_wq
);
285 * function: zfcp_fsf_protstatus_eval
287 * purpose: evaluates the QTCB of the finished FSF request
288 * and initiates appropriate actions
289 * (usually calling FSF command specific handlers)
298 zfcp_fsf_protstatus_eval(struct zfcp_fsf_req
*fsf_req
)
301 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
302 struct fsf_qtcb
*qtcb
= fsf_req
->qtcb
;
303 union fsf_prot_status_qual
*prot_status_qual
=
304 &qtcb
->prefix
.prot_status_qual
;
306 zfcp_hba_dbf_event_fsf_response(fsf_req
);
308 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_DISMISSED
) {
309 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
|
310 ZFCP_STATUS_FSFREQ_RETRY
; /* only for SCSI cmnds. */
311 goto skip_protstatus
;
314 /* evaluate FSF Protocol Status */
315 switch (qtcb
->prefix
.prot_status
) {
318 case FSF_PROT_FSF_STATUS_PRESENTED
:
321 case FSF_PROT_QTCB_VERSION_ERROR
:
322 dev_err(&adapter
->ccw_device
->dev
,
323 "The QTCB version requested by zfcp (0x%x) is not "
324 "supported by the FCP adapter (lowest supported 0x%x, "
325 "highest supported 0x%x).\n",
326 ZFCP_QTCB_VERSION
, prot_status_qual
->word
[0],
327 prot_status_qual
->word
[1]);
328 zfcp_erp_adapter_shutdown(adapter
, 0, 117, fsf_req
);
329 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
332 case FSF_PROT_SEQ_NUMB_ERROR
:
333 zfcp_erp_adapter_reopen(adapter
, 0, 98, fsf_req
);
334 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_RETRY
;
335 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
338 case FSF_PROT_UNSUPP_QTCB_TYPE
:
339 dev_err(&adapter
->ccw_device
->dev
,
340 "Packet header type used by the device driver is "
341 "incompatible with that used on the adapter.\n");
342 zfcp_erp_adapter_shutdown(adapter
, 0, 118, fsf_req
);
343 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
346 case FSF_PROT_HOST_CONNECTION_INITIALIZING
:
347 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
348 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT
,
352 case FSF_PROT_DUPLICATE_REQUEST_ID
:
353 dev_err(&adapter
->ccw_device
->dev
,
354 "The request identifier 0x%Lx is ambiguous.\n",
355 (unsigned long long)qtcb
->bottom
.support
.req_handle
);
356 zfcp_erp_adapter_shutdown(adapter
, 0, 78, fsf_req
);
357 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
360 case FSF_PROT_LINK_DOWN
:
361 zfcp_fsf_link_down_info_eval(fsf_req
, 37,
362 &prot_status_qual
->link_down_info
);
363 /* FIXME: reopening adapter now? better wait for link up */
364 zfcp_erp_adapter_reopen(adapter
, 0, 79, fsf_req
);
365 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
368 case FSF_PROT_REEST_QUEUE
:
369 /* All ports should be marked as ready to run again */
370 zfcp_erp_modify_adapter_status(adapter
, 28, NULL
,
371 ZFCP_STATUS_COMMON_RUNNING
,
373 zfcp_erp_adapter_reopen(adapter
,
374 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
375 | ZFCP_STATUS_COMMON_ERP_FAILED
,
377 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
380 case FSF_PROT_ERROR_STATE
:
381 zfcp_erp_adapter_reopen(adapter
, 0, 100, fsf_req
);
382 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_RETRY
;
383 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
387 dev_err(&adapter
->ccw_device
->dev
,
388 "Transfer protocol status information"
389 "provided by the adapter (0x%x) "
390 "is not compatible with the device driver.\n",
391 qtcb
->prefix
.prot_status
);
392 zfcp_erp_adapter_shutdown(adapter
, 0, 119, fsf_req
);
393 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
398 * always call specific handlers to give them a chance to do
399 * something meaningful even in error cases
401 zfcp_fsf_fsfstatus_eval(fsf_req
);
406 * function: zfcp_fsf_fsfstatus_eval
408 * purpose: evaluates FSF status of completed FSF request
409 * and acts accordingly
414 zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req
*fsf_req
)
418 if (unlikely(fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)) {
422 /* evaluate FSF Status */
423 switch (fsf_req
->qtcb
->header
.fsf_status
) {
424 case FSF_UNKNOWN_COMMAND
:
425 dev_err(&fsf_req
->adapter
->ccw_device
->dev
,
426 "Command issued by the device driver (0x%x) is "
427 "not known by the adapter.\n",
428 fsf_req
->qtcb
->header
.fsf_command
);
429 zfcp_erp_adapter_shutdown(fsf_req
->adapter
, 0, 120, fsf_req
);
430 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
433 case FSF_ADAPTER_STATUS_AVAILABLE
:
434 zfcp_fsf_fsfstatus_qual_eval(fsf_req
);
440 * always call specific handlers to give them a chance to do
441 * something meaningful even in error cases
443 zfcp_fsf_req_dispatch(fsf_req
);
449 * function: zfcp_fsf_fsfstatus_qual_eval
451 * purpose: evaluates FSF status-qualifier of completed FSF request
452 * and acts accordingly
457 zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req
*fsf_req
)
461 switch (fsf_req
->qtcb
->header
.fsf_status_qual
.word
[0]) {
462 case FSF_SQ_FCP_RSP_AVAILABLE
:
464 case FSF_SQ_RETRY_IF_POSSIBLE
:
465 /* The SCSI-stack may now issue retries or escalate */
466 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
468 case FSF_SQ_COMMAND_ABORTED
:
469 /* Carry the aborted state on to upper layer */
470 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ABORTED
;
471 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
473 case FSF_SQ_NO_RECOM
:
474 dev_err(&fsf_req
->adapter
->ccw_device
->dev
,
475 "No recommendation could be given for a "
476 "problem on the adapter.\n");
477 zfcp_erp_adapter_shutdown(fsf_req
->adapter
, 0, 121, fsf_req
);
478 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
480 case FSF_SQ_ULP_PROGRAMMING_ERROR
:
481 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
483 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
484 case FSF_SQ_NO_RETRY_POSSIBLE
:
485 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
486 /* dealt with in the respective functions */
489 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
497 * zfcp_fsf_link_down_info_eval - evaluate link down information block
500 zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req
*fsf_req
, u8 id
,
501 struct fsf_link_down_info
*link_down
)
503 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
505 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
,
509 atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
, &adapter
->status
);
511 if (link_down
== NULL
)
514 switch (link_down
->error_code
) {
515 case FSF_PSQ_LINK_NO_LIGHT
:
516 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
517 "The local link is down: "
518 "no light detected.\n");
520 case FSF_PSQ_LINK_WRAP_PLUG
:
521 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
522 "The local link is down: "
523 "wrap plug detected.\n");
525 case FSF_PSQ_LINK_NO_FCP
:
526 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
527 "The local link is down: "
528 "adjacent node on link does not support FCP.\n");
530 case FSF_PSQ_LINK_FIRMWARE_UPDATE
:
531 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
532 "The local link is down: "
533 "firmware update in progress.\n");
535 case FSF_PSQ_LINK_INVALID_WWPN
:
536 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
537 "The local link is down: "
538 "duplicate or invalid WWPN detected.\n");
540 case FSF_PSQ_LINK_NO_NPIV_SUPPORT
:
541 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
542 "The local link is down: "
543 "no support for NPIV by Fabric.\n");
545 case FSF_PSQ_LINK_NO_FCP_RESOURCES
:
546 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
547 "The local link is down: "
548 "out of resource in FCP daughtercard.\n");
550 case FSF_PSQ_LINK_NO_FABRIC_RESOURCES
:
551 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
552 "The local link is down: "
553 "out of resource in Fabric.\n");
555 case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE
:
556 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
557 "The local link is down: "
558 "unable to login to Fabric.\n");
560 case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED
:
561 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
562 "WWPN assignment file corrupted on adapter.\n");
564 case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED
:
565 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
566 "Mode table corrupted on adapter.\n");
568 case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT
:
569 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
570 "No WWPN for assignment table on adapter.\n");
573 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
574 "The local link to adapter is down.\n");
578 zfcp_erp_adapter_failed(adapter
, id
, fsf_req
);
582 * function: zfcp_fsf_req_dispatch
584 * purpose: calls the appropriate command specific handler
589 zfcp_fsf_req_dispatch(struct zfcp_fsf_req
*fsf_req
)
591 struct zfcp_erp_action
*erp_action
= fsf_req
->erp_action
;
595 switch (fsf_req
->fsf_command
) {
597 case FSF_QTCB_FCP_CMND
:
598 zfcp_fsf_send_fcp_command_handler(fsf_req
);
601 case FSF_QTCB_ABORT_FCP_CMND
:
602 zfcp_fsf_abort_fcp_command_handler(fsf_req
);
605 case FSF_QTCB_SEND_GENERIC
:
606 zfcp_fsf_send_ct_handler(fsf_req
);
609 case FSF_QTCB_OPEN_PORT_WITH_DID
:
610 zfcp_fsf_open_port_handler(fsf_req
);
613 case FSF_QTCB_OPEN_LUN
:
614 zfcp_fsf_open_unit_handler(fsf_req
);
617 case FSF_QTCB_CLOSE_LUN
:
618 zfcp_fsf_close_unit_handler(fsf_req
);
621 case FSF_QTCB_CLOSE_PORT
:
622 zfcp_fsf_close_port_handler(fsf_req
);
625 case FSF_QTCB_CLOSE_PHYSICAL_PORT
:
626 zfcp_fsf_close_physical_port_handler(fsf_req
);
629 case FSF_QTCB_EXCHANGE_CONFIG_DATA
:
630 zfcp_fsf_exchange_config_data_handler(fsf_req
);
633 case FSF_QTCB_EXCHANGE_PORT_DATA
:
634 zfcp_fsf_exchange_port_data_handler(fsf_req
);
637 case FSF_QTCB_SEND_ELS
:
638 zfcp_fsf_send_els_handler(fsf_req
);
641 case FSF_QTCB_DOWNLOAD_CONTROL_FILE
:
642 zfcp_fsf_control_file_handler(fsf_req
);
645 case FSF_QTCB_UPLOAD_CONTROL_FILE
:
646 zfcp_fsf_control_file_handler(fsf_req
);
653 zfcp_erp_async_handler(erp_action
, 0);
659 * function: zfcp_fsf_status_read
661 * purpose: initiates a Status Read command at the specified adapter
666 zfcp_fsf_status_read(struct zfcp_adapter
*adapter
, int req_flags
)
668 struct zfcp_fsf_req
*fsf_req
;
669 struct fsf_status_read_buffer
*status_buffer
;
670 unsigned long lock_flags
;
671 volatile struct qdio_buffer_element
*sbale
;
674 /* setup new FSF request */
675 retval
= zfcp_fsf_req_create(adapter
, FSF_QTCB_UNSOLICITED_STATUS
,
676 req_flags
| ZFCP_REQ_NO_QTCB
,
677 adapter
->pool
.fsf_req_status_read
,
678 &lock_flags
, &fsf_req
);
680 goto failed_req_create
;
682 sbale
= zfcp_qdio_sbale_req(fsf_req
);
683 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_STATUS
;
684 sbale
[2].flags
|= SBAL_FLAGS_LAST_ENTRY
;
685 fsf_req
->sbale_curr
= 2;
689 mempool_alloc(adapter
->pool
.data_status_read
, GFP_ATOMIC
);
692 memset(status_buffer
, 0, sizeof (struct fsf_status_read_buffer
));
693 fsf_req
->data
= (unsigned long) status_buffer
;
695 /* insert pointer to respective buffer */
696 sbale
= zfcp_qdio_sbale_curr(fsf_req
);
697 sbale
->addr
= (void *) status_buffer
;
698 sbale
->length
= sizeof(struct fsf_status_read_buffer
);
700 retval
= zfcp_fsf_req_send(fsf_req
);
702 goto failed_req_send
;
707 mempool_free(status_buffer
, adapter
->pool
.data_status_read
);
710 zfcp_fsf_req_free(fsf_req
);
712 zfcp_hba_dbf_event_fsf_unsol("fail", adapter
, NULL
);
714 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
719 zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req
*fsf_req
)
721 struct fsf_status_read_buffer
*status_buffer
;
722 struct zfcp_adapter
*adapter
;
723 struct zfcp_port
*port
;
726 status_buffer
= (struct fsf_status_read_buffer
*) fsf_req
->data
;
727 adapter
= fsf_req
->adapter
;
729 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
730 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
731 if (port
->d_id
== (status_buffer
->d_id
& ZFCP_DID_MASK
))
733 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
735 if (!port
|| (port
->d_id
!= (status_buffer
->d_id
& ZFCP_DID_MASK
)))
738 switch (status_buffer
->status_subtype
) {
740 case FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT
:
741 zfcp_erp_port_reopen(port
, 0, 101, fsf_req
);
744 case FSF_STATUS_READ_SUB_ERROR_PORT
:
745 zfcp_erp_port_shutdown(port
, 0, 122, fsf_req
);
752 static void zfcp_fsf_bit_error_threshold(struct zfcp_fsf_req
*req
)
754 struct zfcp_adapter
*adapter
= req
->adapter
;
755 struct fsf_status_read_buffer
*buf
=
756 (struct fsf_status_read_buffer
*) req
->data
;
757 struct fsf_bit_error_payload
*err
=
758 (struct fsf_bit_error_payload
*) buf
->payload
;
759 dev_warn(&adapter
->ccw_device
->dev
,
760 "Warning: bit error threshold data "
761 "received for the adapter: "
762 "link failures = %i, loss of sync errors = %i, "
763 "loss of signal errors = %i, "
764 "primitive sequence errors = %i, "
765 "invalid transmission word errors = %i, "
766 "CRC errors = %i).\n",
767 err
->link_failure_error_count
,
768 err
->loss_of_sync_error_count
,
769 err
->loss_of_signal_error_count
,
770 err
->primitive_sequence_error_count
,
771 err
->invalid_transmission_word_error_count
,
772 err
->crc_error_count
);
773 dev_warn(&adapter
->ccw_device
->dev
,
774 "Additional bit error threshold data of the adapter: "
775 "primitive sequence event time-outs = %i, "
776 "elastic buffer overrun errors = %i, "
777 "advertised receive buffer-to-buffer credit = %i, "
778 "current receice buffer-to-buffer credit = %i, "
779 "advertised transmit buffer-to-buffer credit = %i, "
780 "current transmit buffer-to-buffer credit = %i).\n",
781 err
->primitive_sequence_event_timeout_count
,
782 err
->elastic_buffer_overrun_error_count
,
783 err
->advertised_receive_b2b_credit
,
784 err
->current_receive_b2b_credit
,
785 err
->advertised_transmit_b2b_credit
,
786 err
->current_transmit_b2b_credit
);
790 * function: zfcp_fsf_status_read_handler
792 * purpose: is called for finished Open Port command
797 zfcp_fsf_status_read_handler(struct zfcp_fsf_req
*fsf_req
)
800 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
801 struct fsf_status_read_buffer
*status_buffer
=
802 (struct fsf_status_read_buffer
*) fsf_req
->data
;
804 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_DISMISSED
) {
805 zfcp_hba_dbf_event_fsf_unsol("dism", adapter
, status_buffer
);
806 mempool_free(status_buffer
, adapter
->pool
.data_status_read
);
807 zfcp_fsf_req_free(fsf_req
);
811 zfcp_hba_dbf_event_fsf_unsol("read", adapter
, status_buffer
);
813 switch (status_buffer
->status_type
) {
815 case FSF_STATUS_READ_PORT_CLOSED
:
816 zfcp_fsf_status_read_port_closed(fsf_req
);
819 case FSF_STATUS_READ_INCOMING_ELS
:
820 zfcp_fc_incoming_els(fsf_req
);
823 case FSF_STATUS_READ_SENSE_DATA_AVAIL
:
826 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD
:
827 zfcp_fsf_bit_error_threshold(fsf_req
);
830 case FSF_STATUS_READ_LINK_DOWN
:
831 switch (status_buffer
->status_subtype
) {
832 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK
:
833 dev_warn(&adapter
->ccw_device
->dev
,
834 "Physical link is down.\n");
835 zfcp_fsf_link_down_info_eval(fsf_req
, 38,
836 (struct fsf_link_down_info
*)
837 &status_buffer
->payload
);
839 case FSF_STATUS_READ_SUB_FDISC_FAILED
:
840 dev_warn(&adapter
->ccw_device
->dev
,
841 "Local link is down "
842 "due to failed FDISC login.\n");
843 zfcp_fsf_link_down_info_eval(fsf_req
, 39,
844 (struct fsf_link_down_info
*)
845 &status_buffer
->payload
);
847 case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE
:
848 dev_warn(&adapter
->ccw_device
->dev
,
849 "Local link is down "
850 "due to firmware update on adapter.\n");
851 zfcp_fsf_link_down_info_eval(fsf_req
, 40, NULL
);
854 dev_warn(&adapter
->ccw_device
->dev
,
855 "Local link is down.\n");
856 zfcp_fsf_link_down_info_eval(fsf_req
, 41, NULL
);
860 case FSF_STATUS_READ_LINK_UP
:
861 dev_info(&adapter
->ccw_device
->dev
,
862 "Local link was replugged.\n");
863 /* All ports should be marked as ready to run again */
864 zfcp_erp_modify_adapter_status(adapter
, 30, NULL
,
865 ZFCP_STATUS_COMMON_RUNNING
,
867 zfcp_erp_adapter_reopen(adapter
,
868 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
869 | ZFCP_STATUS_COMMON_ERP_FAILED
,
873 case FSF_STATUS_READ_NOTIFICATION_LOST
:
874 if (status_buffer
->status_subtype
&
875 FSF_STATUS_READ_SUB_ACT_UPDATED
)
876 zfcp_erp_adapter_access_changed(adapter
, 135, fsf_req
);
877 if (status_buffer
->status_subtype
&
878 FSF_STATUS_READ_SUB_INCOMING_ELS
)
879 schedule_work(&adapter
->scan_work
);
882 case FSF_STATUS_READ_CFDC_UPDATED
:
883 zfcp_erp_adapter_access_changed(adapter
, 136, fsf_req
);
886 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT
:
887 adapter
->adapter_features
= *(u32
*) status_buffer
->payload
;
890 mempool_free(status_buffer
, adapter
->pool
.data_status_read
);
891 zfcp_fsf_req_free(fsf_req
);
893 * recycle buffer and start new request repeat until outbound
894 * queue is empty or adapter shutdown is requested
898 * we may wait in the req_create for 5s during shutdown, so
899 * qdio_cleanup will have to wait at least that long before returning
900 * with failure to allow us a proper cleanup under all circumstances
904 * allocation failure possible? (Is this code needed?)
907 atomic_inc(&adapter
->stat_miss
);
908 schedule_work(&adapter
->stat_work
);
914 * function: zfcp_fsf_abort_fcp_command
916 * purpose: tells FSF to abort a running SCSI command
918 * returns: address of initiated FSF request
919 * NULL - request could not be initiated
921 * FIXME(design): should be watched by a timeout !!!
922 * FIXME(design) shouldn't this be modified to return an int
923 * also...don't know how though
925 struct zfcp_fsf_req
*
926 zfcp_fsf_abort_fcp_command(unsigned long old_req_id
,
927 struct zfcp_adapter
*adapter
,
928 struct zfcp_unit
*unit
, int req_flags
)
930 volatile struct qdio_buffer_element
*sbale
;
931 struct zfcp_fsf_req
*fsf_req
= NULL
;
932 unsigned long lock_flags
;
935 /* setup new FSF request */
936 retval
= zfcp_fsf_req_create(adapter
, FSF_QTCB_ABORT_FCP_CMND
,
937 req_flags
, adapter
->pool
.fsf_req_abort
,
938 &lock_flags
, &fsf_req
);
942 if (unlikely(!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
,
946 sbale
= zfcp_qdio_sbale_req(fsf_req
);
947 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
948 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
950 fsf_req
->data
= (unsigned long) unit
;
952 /* set handles of unit and its parent port in QTCB */
953 fsf_req
->qtcb
->header
.lun_handle
= unit
->handle
;
954 fsf_req
->qtcb
->header
.port_handle
= unit
->port
->handle
;
956 /* set handle of request which should be aborted */
957 fsf_req
->qtcb
->bottom
.support
.req_handle
= (u64
) old_req_id
;
959 zfcp_fsf_start_timer(fsf_req
, ZFCP_SCSI_ER_TIMEOUT
);
960 retval
= zfcp_fsf_req_send(fsf_req
);
965 zfcp_fsf_req_free(fsf_req
);
969 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
974 * function: zfcp_fsf_abort_fcp_command_handler
976 * purpose: is called for finished Abort FCP Command request
981 zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req
*new_fsf_req
)
983 int retval
= -EINVAL
;
984 struct zfcp_unit
*unit
;
985 union fsf_status_qual
*fsf_stat_qual
=
986 &new_fsf_req
->qtcb
->header
.fsf_status_qual
;
988 if (new_fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
989 /* do not set ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED */
993 unit
= (struct zfcp_unit
*) new_fsf_req
->data
;
995 /* evaluate FSF status in QTCB */
996 switch (new_fsf_req
->qtcb
->header
.fsf_status
) {
998 case FSF_PORT_HANDLE_NOT_VALID
:
999 if (fsf_stat_qual
->word
[0] != fsf_stat_qual
->word
[1]) {
1001 * In this case a command that was sent prior to a port
1002 * reopen was aborted (handles are different). This is
1006 /* Let's hope this sorts out the mess */
1007 zfcp_erp_adapter_reopen(unit
->port
->adapter
, 0, 104,
1009 new_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1013 case FSF_LUN_HANDLE_NOT_VALID
:
1014 if (fsf_stat_qual
->word
[0] != fsf_stat_qual
->word
[1]) {
1016 * In this case a command that was sent prior to a unit
1017 * reopen was aborted (handles are different).
1021 /* Let's hope this sorts out the mess */
1022 zfcp_erp_port_reopen(unit
->port
, 0, 105, new_fsf_req
);
1023 new_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1027 case FSF_FCP_COMMAND_DOES_NOT_EXIST
:
1029 new_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED
;
1032 case FSF_PORT_BOXED
:
1033 zfcp_erp_port_boxed(unit
->port
, 47, new_fsf_req
);
1034 new_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
1035 | ZFCP_STATUS_FSFREQ_RETRY
;
1039 zfcp_erp_unit_boxed(unit
, 48, new_fsf_req
);
1040 new_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
1041 | ZFCP_STATUS_FSFREQ_RETRY
;
1044 case FSF_ADAPTER_STATUS_AVAILABLE
:
1045 switch (new_fsf_req
->qtcb
->header
.fsf_status_qual
.word
[0]) {
1046 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1047 zfcp_test_link(unit
->port
);
1048 new_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1050 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1051 /* SCSI stack will escalate */
1052 new_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1059 new_fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED
;
1067 * zfcp_use_one_sbal - checks whether req buffer and resp bother each fit into
1069 * Two scatter-gather lists are passed, one for the reqeust and one for the
1073 zfcp_use_one_sbal(struct scatterlist
*req
, int req_count
,
1074 struct scatterlist
*resp
, int resp_count
)
1076 return ((req_count
== 1) &&
1077 (resp_count
== 1) &&
1078 (((unsigned long) zfcp_sg_to_address(&req
[0]) &
1080 ((unsigned long) (zfcp_sg_to_address(&req
[0]) +
1081 req
[0].length
- 1) & PAGE_MASK
)) &&
1082 (((unsigned long) zfcp_sg_to_address(&resp
[0]) &
1084 ((unsigned long) (zfcp_sg_to_address(&resp
[0]) +
1085 resp
[0].length
- 1) & PAGE_MASK
)));
1089 * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
1090 * @ct: pointer to struct zfcp_send_ct which conatins all needed data for
1092 * @pool: pointer to memory pool, if non-null this pool is used to allocate
1093 * a struct zfcp_fsf_req
1094 * @erp_action: pointer to erp_action, if non-null the Generic Service request
1095 * is sent within error recovery
1098 zfcp_fsf_send_ct(struct zfcp_send_ct
*ct
, mempool_t
*pool
,
1099 struct zfcp_erp_action
*erp_action
)
1101 volatile struct qdio_buffer_element
*sbale
;
1102 struct zfcp_port
*port
;
1103 struct zfcp_adapter
*adapter
;
1104 struct zfcp_fsf_req
*fsf_req
;
1105 unsigned long lock_flags
;
1110 adapter
= port
->adapter
;
1112 ret
= zfcp_fsf_req_create(adapter
, FSF_QTCB_SEND_GENERIC
,
1113 ZFCP_WAIT_FOR_SBAL
| ZFCP_REQ_AUTO_CLEANUP
,
1114 pool
, &lock_flags
, &fsf_req
);
1118 sbale
= zfcp_qdio_sbale_req(fsf_req
);
1119 if (zfcp_use_one_sbal(ct
->req
, ct
->req_count
,
1120 ct
->resp
, ct
->resp_count
)){
1121 /* both request buffer and response buffer
1122 fit into one sbale each */
1123 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_WRITE_READ
;
1124 sbale
[2].addr
= zfcp_sg_to_address(&ct
->req
[0]);
1125 sbale
[2].length
= ct
->req
[0].length
;
1126 sbale
[3].addr
= zfcp_sg_to_address(&ct
->resp
[0]);
1127 sbale
[3].length
= ct
->resp
[0].length
;
1128 sbale
[3].flags
|= SBAL_FLAGS_LAST_ENTRY
;
1129 } else if (adapter
->adapter_features
&
1130 FSF_FEATURE_ELS_CT_CHAINED_SBALS
) {
1131 /* try to use chained SBALs */
1132 bytes
= zfcp_qdio_sbals_from_sg(fsf_req
,
1133 SBAL_FLAGS0_TYPE_WRITE_READ
,
1135 ZFCP_MAX_SBALS_PER_CT_REQ
);
1144 fsf_req
->qtcb
->bottom
.support
.req_buf_length
= bytes
;
1145 fsf_req
->sbale_curr
= ZFCP_LAST_SBALE_PER_SBAL
;
1146 bytes
= zfcp_qdio_sbals_from_sg(fsf_req
,
1147 SBAL_FLAGS0_TYPE_WRITE_READ
,
1149 ZFCP_MAX_SBALS_PER_CT_REQ
);
1158 fsf_req
->qtcb
->bottom
.support
.resp_buf_length
= bytes
;
1160 /* reject send generic request */
1165 /* settings in QTCB */
1166 fsf_req
->qtcb
->header
.port_handle
= port
->handle
;
1167 fsf_req
->qtcb
->bottom
.support
.service_class
=
1168 ZFCP_FC_SERVICE_CLASS_DEFAULT
;
1169 fsf_req
->qtcb
->bottom
.support
.timeout
= ct
->timeout
;
1170 fsf_req
->data
= (unsigned long) ct
;
1172 zfcp_san_dbf_event_ct_request(fsf_req
);
1175 erp_action
->fsf_req
= fsf_req
;
1176 fsf_req
->erp_action
= erp_action
;
1177 zfcp_erp_start_timer(fsf_req
);
1179 zfcp_fsf_start_timer(fsf_req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1181 ret
= zfcp_fsf_req_send(fsf_req
);
1188 zfcp_fsf_req_free(fsf_req
);
1189 if (erp_action
!= NULL
) {
1190 erp_action
->fsf_req
= NULL
;
1194 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1199 * zfcp_fsf_send_ct_handler - handler for Generic Service requests
1200 * @fsf_req: pointer to struct zfcp_fsf_req
1202 * Data specific for the Generic Service request is passed using
1203 * fsf_req->data. There we find the pointer to struct zfcp_send_ct.
1204 * Usually a specific handler for the CT request is called which is
1205 * found in this structure.
1208 zfcp_fsf_send_ct_handler(struct zfcp_fsf_req
*fsf_req
)
1210 struct zfcp_port
*port
;
1211 struct zfcp_adapter
*adapter
;
1212 struct zfcp_send_ct
*send_ct
;
1213 struct fsf_qtcb_header
*header
;
1214 struct fsf_qtcb_bottom_support
*bottom
;
1215 int retval
= -EINVAL
;
1217 adapter
= fsf_req
->adapter
;
1218 send_ct
= (struct zfcp_send_ct
*) fsf_req
->data
;
1219 port
= send_ct
->port
;
1220 header
= &fsf_req
->qtcb
->header
;
1221 bottom
= &fsf_req
->qtcb
->bottom
.support
;
1223 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1224 goto skip_fsfstatus
;
1226 /* evaluate FSF status in QTCB */
1227 switch (header
->fsf_status
) {
1230 zfcp_san_dbf_event_ct_response(fsf_req
);
1234 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
1235 zfcp_fsf_class_not_supp(fsf_req
);
1238 case FSF_ADAPTER_STATUS_AVAILABLE
:
1239 switch (header
->fsf_status_qual
.word
[0]){
1240 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1241 /* reopening link to port */
1242 zfcp_test_link(port
);
1243 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1245 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1246 /* ERP strategy will escalate */
1247 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1252 case FSF_ACCESS_DENIED
:
1253 zfcp_fsf_access_denied_port(fsf_req
, port
);
1256 case FSF_GENERIC_COMMAND_REJECTED
:
1257 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1260 case FSF_PORT_HANDLE_NOT_VALID
:
1261 zfcp_erp_adapter_reopen(adapter
, 0, 106, fsf_req
);
1262 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1265 case FSF_PORT_BOXED
:
1266 zfcp_erp_port_boxed(port
, 49, fsf_req
);
1267 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
1268 | ZFCP_STATUS_FSFREQ_RETRY
;
1271 /* following states should never occure, all cases avoided
1272 in zfcp_fsf_send_ct - but who knows ... */
1273 case FSF_PAYLOAD_SIZE_MISMATCH
:
1274 case FSF_REQUEST_SIZE_TOO_LARGE
:
1275 case FSF_RESPONSE_SIZE_TOO_LARGE
:
1276 case FSF_SBAL_MISMATCH
:
1277 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1285 send_ct
->status
= retval
;
1287 if (send_ct
->handler
!= NULL
)
1288 send_ct
->handler(send_ct
->handler_data
);
1294 * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
1295 * @els: pointer to struct zfcp_send_els which contains all needed data for
1299 zfcp_fsf_send_els(struct zfcp_send_els
*els
)
1301 volatile struct qdio_buffer_element
*sbale
;
1302 struct zfcp_fsf_req
*fsf_req
;
1304 struct zfcp_adapter
*adapter
;
1305 unsigned long lock_flags
;
1310 adapter
= els
->adapter
;
1312 ret
= zfcp_fsf_req_create(adapter
, FSF_QTCB_SEND_ELS
,
1313 ZFCP_REQ_AUTO_CLEANUP
,
1314 NULL
, &lock_flags
, &fsf_req
);
1318 if (unlikely(!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
,
1319 &els
->port
->status
))) {
1324 sbale
= zfcp_qdio_sbale_req(fsf_req
);
1325 if (zfcp_use_one_sbal(els
->req
, els
->req_count
,
1326 els
->resp
, els
->resp_count
)){
1327 /* both request buffer and response buffer
1328 fit into one sbale each */
1329 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_WRITE_READ
;
1330 sbale
[2].addr
= zfcp_sg_to_address(&els
->req
[0]);
1331 sbale
[2].length
= els
->req
[0].length
;
1332 sbale
[3].addr
= zfcp_sg_to_address(&els
->resp
[0]);
1333 sbale
[3].length
= els
->resp
[0].length
;
1334 sbale
[3].flags
|= SBAL_FLAGS_LAST_ENTRY
;
1335 } else if (adapter
->adapter_features
&
1336 FSF_FEATURE_ELS_CT_CHAINED_SBALS
) {
1337 /* try to use chained SBALs */
1338 bytes
= zfcp_qdio_sbals_from_sg(fsf_req
,
1339 SBAL_FLAGS0_TYPE_WRITE_READ
,
1341 ZFCP_MAX_SBALS_PER_ELS_REQ
);
1350 fsf_req
->qtcb
->bottom
.support
.req_buf_length
= bytes
;
1351 fsf_req
->sbale_curr
= ZFCP_LAST_SBALE_PER_SBAL
;
1352 bytes
= zfcp_qdio_sbals_from_sg(fsf_req
,
1353 SBAL_FLAGS0_TYPE_WRITE_READ
,
1355 ZFCP_MAX_SBALS_PER_ELS_REQ
);
1364 fsf_req
->qtcb
->bottom
.support
.resp_buf_length
= bytes
;
1366 /* reject request */
1371 /* settings in QTCB */
1372 fsf_req
->qtcb
->bottom
.support
.d_id
= d_id
;
1373 fsf_req
->qtcb
->bottom
.support
.service_class
=
1374 ZFCP_FC_SERVICE_CLASS_DEFAULT
;
1375 fsf_req
->qtcb
->bottom
.support
.timeout
= ZFCP_ELS_TIMEOUT
;
1376 fsf_req
->data
= (unsigned long) els
;
1378 sbale
= zfcp_qdio_sbale_req(fsf_req
);
1380 zfcp_san_dbf_event_els_request(fsf_req
);
1382 zfcp_fsf_start_timer(fsf_req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1383 ret
= zfcp_fsf_req_send(fsf_req
);
1391 zfcp_fsf_req_free(fsf_req
);
1395 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1401 * zfcp_fsf_send_els_handler - handler for ELS commands
1402 * @fsf_req: pointer to struct zfcp_fsf_req
1404 * Data specific for the ELS command is passed using
1405 * fsf_req->data. There we find the pointer to struct zfcp_send_els.
1406 * Usually a specific handler for the ELS command is called which is
1407 * found in this structure.
1409 static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req
*fsf_req
)
1411 struct zfcp_adapter
*adapter
;
1412 struct zfcp_port
*port
;
1414 struct fsf_qtcb_header
*header
;
1415 struct fsf_qtcb_bottom_support
*bottom
;
1416 struct zfcp_send_els
*send_els
;
1417 int retval
= -EINVAL
;
1419 send_els
= (struct zfcp_send_els
*) fsf_req
->data
;
1420 adapter
= send_els
->adapter
;
1421 port
= send_els
->port
;
1422 d_id
= send_els
->d_id
;
1423 header
= &fsf_req
->qtcb
->header
;
1424 bottom
= &fsf_req
->qtcb
->bottom
.support
;
1426 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1427 goto skip_fsfstatus
;
1429 switch (header
->fsf_status
) {
1432 zfcp_san_dbf_event_els_response(fsf_req
);
1436 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
1437 zfcp_fsf_class_not_supp(fsf_req
);
1440 case FSF_ADAPTER_STATUS_AVAILABLE
:
1441 switch (header
->fsf_status_qual
.word
[0]){
1442 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1443 if (port
&& (send_els
->ls_code
!= ZFCP_LS_ADISC
))
1444 zfcp_test_link(port
);
1445 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1447 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1448 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1450 case FSF_SQ_RETRY_IF_POSSIBLE
:
1451 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1456 case FSF_ELS_COMMAND_REJECTED
:
1457 case FSF_PAYLOAD_SIZE_MISMATCH
:
1458 case FSF_REQUEST_SIZE_TOO_LARGE
:
1459 case FSF_RESPONSE_SIZE_TOO_LARGE
:
1462 case FSF_SBAL_MISMATCH
:
1463 /* should never occure, avoided in zfcp_fsf_send_els */
1464 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1467 case FSF_ACCESS_DENIED
:
1468 zfcp_fsf_access_denied_port(fsf_req
, port
);
1472 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1477 send_els
->status
= retval
;
1479 if (send_els
->handler
)
1480 send_els
->handler(send_els
->handler_data
);
1486 zfcp_fsf_exchange_config_data(struct zfcp_erp_action
*erp_action
)
1488 volatile struct qdio_buffer_element
*sbale
;
1489 struct zfcp_fsf_req
*fsf_req
;
1490 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
1491 unsigned long lock_flags
;
1494 /* setup new FSF request */
1495 retval
= zfcp_fsf_req_create(adapter
,
1496 FSF_QTCB_EXCHANGE_CONFIG_DATA
,
1497 ZFCP_REQ_AUTO_CLEANUP
,
1498 adapter
->pool
.fsf_req_erp
,
1499 &lock_flags
, &fsf_req
);
1501 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1505 sbale
= zfcp_qdio_sbale_req(fsf_req
);
1506 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
1507 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
1509 fsf_req
->qtcb
->bottom
.config
.feature_selection
=
1511 FSF_FEATURE_LUN_SHARING
|
1512 FSF_FEATURE_NOTIFICATION_LOST
|
1513 FSF_FEATURE_UPDATE_ALERT
;
1514 fsf_req
->erp_action
= erp_action
;
1515 erp_action
->fsf_req
= fsf_req
;
1517 zfcp_erp_start_timer(fsf_req
);
1518 retval
= zfcp_fsf_req_send(fsf_req
);
1519 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1521 zfcp_fsf_req_free(fsf_req
);
1522 erp_action
->fsf_req
= NULL
;
1529 zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter
*adapter
,
1530 struct fsf_qtcb_bottom_config
*data
)
1532 volatile struct qdio_buffer_element
*sbale
;
1533 struct zfcp_fsf_req
*fsf_req
;
1534 unsigned long lock_flags
;
1537 /* setup new FSF request */
1538 retval
= zfcp_fsf_req_create(adapter
, FSF_QTCB_EXCHANGE_CONFIG_DATA
,
1539 ZFCP_WAIT_FOR_SBAL
, NULL
, &lock_flags
,
1542 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1546 sbale
= zfcp_qdio_sbale_req(fsf_req
);
1547 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
1548 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
1550 fsf_req
->qtcb
->bottom
.config
.feature_selection
=
1552 FSF_FEATURE_LUN_SHARING
|
1553 FSF_FEATURE_NOTIFICATION_LOST
|
1554 FSF_FEATURE_UPDATE_ALERT
;
1557 fsf_req
->data
= (unsigned long) data
;
1559 zfcp_fsf_start_timer(fsf_req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1560 retval
= zfcp_fsf_req_send(fsf_req
);
1561 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1563 wait_event(fsf_req
->completion_wq
,
1564 fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
1566 zfcp_fsf_req_free(fsf_req
);
1572 * zfcp_fsf_exchange_config_evaluate
1573 * @fsf_req: fsf_req which belongs to xchg config data request
1574 * @xchg_ok: specifies if xchg config data was incomplete or complete (0/1)
1576 * returns: -EIO on error, 0 otherwise
1579 zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req
*fsf_req
, int xchg_ok
)
1581 struct fsf_qtcb_bottom_config
*bottom
;
1582 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
1583 struct Scsi_Host
*shost
= adapter
->scsi_host
;
1585 bottom
= &fsf_req
->qtcb
->bottom
.config
;
1586 adapter
->fsf_lic_version
= bottom
->lic_version
;
1587 adapter
->adapter_features
= bottom
->adapter_features
;
1588 adapter
->connection_features
= bottom
->connection_features
;
1589 adapter
->peer_wwpn
= 0;
1590 adapter
->peer_wwnn
= 0;
1591 adapter
->peer_d_id
= 0;
1596 memcpy((struct fsf_qtcb_bottom_config
*) fsf_req
->data
,
1597 bottom
, sizeof (struct fsf_qtcb_bottom_config
));
1599 fc_host_node_name(shost
) = bottom
->nport_serv_param
.wwnn
;
1600 fc_host_port_name(shost
) = bottom
->nport_serv_param
.wwpn
;
1601 fc_host_port_id(shost
) = bottom
->s_id
& ZFCP_DID_MASK
;
1602 fc_host_speed(shost
) = bottom
->fc_link_speed
;
1603 fc_host_supported_classes(shost
) =
1604 FC_COS_CLASS2
| FC_COS_CLASS3
;
1605 adapter
->hydra_version
= bottom
->adapter_type
;
1606 adapter
->timer_ticks
= bottom
->timer_interval
;
1607 if (fc_host_permanent_port_name(shost
) == -1)
1608 fc_host_permanent_port_name(shost
) =
1609 fc_host_port_name(shost
);
1610 if (bottom
->fc_topology
== FSF_TOPO_P2P
) {
1611 adapter
->peer_d_id
= bottom
->peer_d_id
& ZFCP_DID_MASK
;
1612 adapter
->peer_wwpn
= bottom
->plogi_payload
.wwpn
;
1613 adapter
->peer_wwnn
= bottom
->plogi_payload
.wwnn
;
1614 fc_host_port_type(shost
) = FC_PORTTYPE_PTP
;
1615 } else if (bottom
->fc_topology
== FSF_TOPO_FABRIC
)
1616 fc_host_port_type(shost
) = FC_PORTTYPE_NPORT
;
1617 else if (bottom
->fc_topology
== FSF_TOPO_AL
)
1618 fc_host_port_type(shost
) = FC_PORTTYPE_NLPORT
;
1620 fc_host_port_type(shost
) = FC_PORTTYPE_UNKNOWN
;
1622 fc_host_node_name(shost
) = 0;
1623 fc_host_port_name(shost
) = 0;
1624 fc_host_port_id(shost
) = 0;
1625 fc_host_speed(shost
) = FC_PORTSPEED_UNKNOWN
;
1626 fc_host_port_type(shost
) = FC_PORTTYPE_UNKNOWN
;
1627 adapter
->hydra_version
= 0;
1630 if (adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
) {
1631 adapter
->hardware_version
= bottom
->hardware_version
;
1632 memcpy(fc_host_serial_number(shost
), bottom
->serial_number
,
1633 min(FC_SERIAL_NUMBER_SIZE
, 17));
1634 EBCASC(fc_host_serial_number(shost
),
1635 min(FC_SERIAL_NUMBER_SIZE
, 17));
1638 if (ZFCP_QTCB_VERSION
< bottom
->low_qtcb_version
) {
1639 dev_err(&adapter
->ccw_device
->dev
,
1640 "The adapter only supports newer control block "
1641 "versions, try updated device driver.\n");
1642 zfcp_erp_adapter_shutdown(adapter
, 0, 125, fsf_req
);
1645 if (ZFCP_QTCB_VERSION
> bottom
->high_qtcb_version
) {
1646 dev_err(&adapter
->ccw_device
->dev
,
1647 "The adapter only supports older control block "
1648 "versions, consider a microcode upgrade.\n");
1649 zfcp_erp_adapter_shutdown(adapter
, 0, 126, fsf_req
);
1656 * function: zfcp_fsf_exchange_config_data_handler
1658 * purpose: is called for finished Exchange Configuration Data command
1663 zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req
*fsf_req
)
1665 struct fsf_qtcb_bottom_config
*bottom
;
1666 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
1667 struct fsf_qtcb
*qtcb
= fsf_req
->qtcb
;
1669 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1672 switch (qtcb
->header
.fsf_status
) {
1675 if (zfcp_fsf_exchange_config_evaluate(fsf_req
, 1))
1678 switch (fc_host_port_type(adapter
->scsi_host
)) {
1679 case FC_PORTTYPE_PTP
:
1680 if (fsf_req
->erp_action
)
1681 dev_info(&adapter
->ccw_device
->dev
,
1682 "Point-to-Point fibrechannel "
1683 "configuration detected.\n");
1685 case FC_PORTTYPE_NLPORT
:
1686 dev_err(&adapter
->ccw_device
->dev
,
1687 "Unsupported arbitrated loop fibrechannel "
1688 "topology detected, shutting down adapter\n");
1689 zfcp_erp_adapter_shutdown(adapter
, 0, 127, fsf_req
);
1691 case FC_PORTTYPE_NPORT
:
1692 if (fsf_req
->erp_action
)
1693 dev_info(&adapter
->ccw_device
->dev
,
1694 "Switched fabric fibrechannel "
1695 "network detected.\n");
1698 dev_err(&adapter
->ccw_device
->dev
,
1699 "The fibrechannel topology reported by the "
1700 "adapter is not known by the zfcp driver, "
1701 "shutting down adapter.\n");
1702 zfcp_erp_adapter_shutdown(adapter
, 0, 128, fsf_req
);
1705 bottom
= &qtcb
->bottom
.config
;
1706 if (bottom
->max_qtcb_size
< sizeof(struct fsf_qtcb
)) {
1707 dev_err(&adapter
->ccw_device
->dev
,
1708 "Maximum QTCB size (%d bytes) allowed by "
1709 "the adapter is lower than the minimum "
1710 "required by the driver (%ld bytes).\n",
1711 bottom
->max_qtcb_size
, sizeof(struct fsf_qtcb
));
1712 zfcp_erp_adapter_shutdown(adapter
, 0, 129, fsf_req
);
1715 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK
,
1718 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE
:
1719 if (zfcp_fsf_exchange_config_evaluate(fsf_req
, 0))
1722 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK
,
1725 zfcp_fsf_link_down_info_eval(fsf_req
, 42,
1726 &qtcb
->header
.fsf_status_qual
.link_down_info
);
1729 zfcp_erp_adapter_shutdown(adapter
, 0, 130, fsf_req
);
1736 * zfcp_fsf_exchange_port_data - request information about local port
1737 * @erp_action: ERP action for the adapter for which port data is requested
1740 zfcp_fsf_exchange_port_data(struct zfcp_erp_action
*erp_action
)
1742 volatile struct qdio_buffer_element
*sbale
;
1743 struct zfcp_fsf_req
*fsf_req
;
1744 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
1745 unsigned long lock_flags
;
1748 if (!(adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
))
1751 /* setup new FSF request */
1752 retval
= zfcp_fsf_req_create(adapter
, FSF_QTCB_EXCHANGE_PORT_DATA
,
1753 ZFCP_REQ_AUTO_CLEANUP
,
1754 adapter
->pool
.fsf_req_erp
,
1755 &lock_flags
, &fsf_req
);
1757 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1761 sbale
= zfcp_qdio_sbale_req(fsf_req
);
1762 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
1763 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
1765 erp_action
->fsf_req
= fsf_req
;
1766 fsf_req
->erp_action
= erp_action
;
1767 zfcp_erp_start_timer(fsf_req
);
1769 retval
= zfcp_fsf_req_send(fsf_req
);
1770 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1773 zfcp_fsf_req_free(fsf_req
);
1774 erp_action
->fsf_req
= NULL
;
1781 * zfcp_fsf_exchange_port_data_sync - request information about local port
1782 * and wait until information is ready
1785 zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter
*adapter
,
1786 struct fsf_qtcb_bottom_port
*data
)
1788 volatile struct qdio_buffer_element
*sbale
;
1789 struct zfcp_fsf_req
*fsf_req
;
1790 unsigned long lock_flags
;
1793 if (!(adapter
->adapter_features
& FSF_FEATURE_HBAAPI_MANAGEMENT
))
1796 /* setup new FSF request */
1797 retval
= zfcp_fsf_req_create(adapter
, FSF_QTCB_EXCHANGE_PORT_DATA
,
1798 0, NULL
, &lock_flags
, &fsf_req
);
1800 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1805 fsf_req
->data
= (unsigned long) data
;
1807 sbale
= zfcp_qdio_sbale_req(fsf_req
);
1808 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
1809 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
1811 zfcp_fsf_start_timer(fsf_req
, ZFCP_FSF_REQUEST_TIMEOUT
);
1812 retval
= zfcp_fsf_req_send(fsf_req
);
1813 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
1816 wait_event(fsf_req
->completion_wq
,
1817 fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
1819 zfcp_fsf_req_free(fsf_req
);
1825 * zfcp_fsf_exchange_port_evaluate
1826 * @fsf_req: fsf_req which belongs to xchg port data request
1827 * @xchg_ok: specifies if xchg port data was incomplete or complete (0/1)
1830 zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req
*fsf_req
, int xchg_ok
)
1832 struct zfcp_adapter
*adapter
;
1833 struct fsf_qtcb_bottom_port
*bottom
;
1834 struct Scsi_Host
*shost
;
1836 adapter
= fsf_req
->adapter
;
1837 bottom
= &fsf_req
->qtcb
->bottom
.port
;
1838 shost
= adapter
->scsi_host
;
1841 memcpy((struct fsf_qtcb_bottom_port
*) fsf_req
->data
, bottom
,
1842 sizeof(struct fsf_qtcb_bottom_port
));
1844 if (adapter
->connection_features
& FSF_FEATURE_NPIV_MODE
)
1845 fc_host_permanent_port_name(shost
) = bottom
->wwpn
;
1847 fc_host_permanent_port_name(shost
) = fc_host_port_name(shost
);
1848 fc_host_maxframe_size(shost
) = bottom
->maximum_frame_size
;
1849 fc_host_supported_speeds(shost
) = bottom
->supported_speed
;
1853 * zfcp_fsf_exchange_port_data_handler - handler for exchange_port_data request
1854 * @fsf_req: pointer to struct zfcp_fsf_req
1857 zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req
*fsf_req
)
1859 struct zfcp_adapter
*adapter
;
1860 struct fsf_qtcb
*qtcb
;
1862 adapter
= fsf_req
->adapter
;
1863 qtcb
= fsf_req
->qtcb
;
1865 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)
1868 switch (qtcb
->header
.fsf_status
) {
1870 zfcp_fsf_exchange_port_evaluate(fsf_req
, 1);
1871 atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK
, &adapter
->status
);
1873 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE
:
1874 zfcp_fsf_exchange_port_evaluate(fsf_req
, 0);
1875 atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK
, &adapter
->status
);
1876 zfcp_fsf_link_down_info_eval(fsf_req
, 43,
1877 &qtcb
->header
.fsf_status_qual
.link_down_info
);
1884 * function: zfcp_fsf_open_port
1888 * returns: address of initiated FSF request
1889 * NULL - request could not be initiated
1892 zfcp_fsf_open_port(struct zfcp_erp_action
*erp_action
)
1894 volatile struct qdio_buffer_element
*sbale
;
1895 struct zfcp_fsf_req
*fsf_req
;
1896 unsigned long lock_flags
;
1899 /* setup new FSF request */
1900 retval
= zfcp_fsf_req_create(erp_action
->adapter
,
1901 FSF_QTCB_OPEN_PORT_WITH_DID
,
1902 ZFCP_WAIT_FOR_SBAL
| ZFCP_REQ_AUTO_CLEANUP
,
1903 erp_action
->adapter
->pool
.fsf_req_erp
,
1904 &lock_flags
, &fsf_req
);
1908 sbale
= zfcp_qdio_sbale_req(fsf_req
);
1909 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
1910 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
1912 fsf_req
->qtcb
->bottom
.support
.d_id
= erp_action
->port
->d_id
;
1913 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING
, &erp_action
->port
->status
);
1914 fsf_req
->data
= (unsigned long) erp_action
->port
;
1915 fsf_req
->erp_action
= erp_action
;
1916 erp_action
->fsf_req
= fsf_req
;
1918 zfcp_erp_start_timer(fsf_req
);
1919 retval
= zfcp_fsf_req_send(fsf_req
);
1921 zfcp_fsf_req_free(fsf_req
);
1922 erp_action
->fsf_req
= NULL
;
1927 write_unlock_irqrestore(&erp_action
->adapter
->req_q
.lock
, lock_flags
);
1932 * function: zfcp_fsf_open_port_handler
1934 * purpose: is called for finished Open Port command
1939 zfcp_fsf_open_port_handler(struct zfcp_fsf_req
*fsf_req
)
1941 int retval
= -EINVAL
;
1942 struct zfcp_port
*port
;
1943 struct fsf_plogi
*plogi
;
1944 struct fsf_qtcb_header
*header
;
1946 port
= (struct zfcp_port
*) fsf_req
->data
;
1947 header
= &fsf_req
->qtcb
->header
;
1949 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
1950 /* don't change port status in our bookkeeping */
1951 goto skip_fsfstatus
;
1954 /* evaluate FSF status in QTCB */
1955 switch (header
->fsf_status
) {
1957 case FSF_PORT_ALREADY_OPEN
:
1959 * This is a bug, however operation should continue normally
1960 * if it is simply ignored
1964 case FSF_ACCESS_DENIED
:
1965 zfcp_fsf_access_denied_port(fsf_req
, port
);
1968 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED
:
1969 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
1970 "The adapter is out of resources. The remote port "
1971 "0x%016Lx could not be opened, disabling it.\n",
1973 zfcp_erp_port_failed(port
, 31, fsf_req
);
1974 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1977 case FSF_ADAPTER_STATUS_AVAILABLE
:
1978 switch (header
->fsf_status_qual
.word
[0]) {
1979 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
1980 /* ERP strategy will escalate */
1981 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1983 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
1984 /* ERP strategy will escalate */
1985 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
1987 case FSF_SQ_NO_RETRY_POSSIBLE
:
1988 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
1989 "The remote port 0x%016Lx could not be "
1990 "opened. Disabling it.\n", port
->wwpn
);
1991 zfcp_erp_port_failed(port
, 32, fsf_req
);
1992 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2000 /* save port handle assigned by FSF */
2001 port
->handle
= header
->port_handle
;
2002 /* mark port as open */
2003 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN
|
2004 ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
2005 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED
|
2006 ZFCP_STATUS_COMMON_ACCESS_BOXED
,
2009 /* check whether D_ID has changed during open */
2011 * FIXME: This check is not airtight, as the FCP channel does
2012 * not monitor closures of target port connections caused on
2013 * the remote side. Thus, they might miss out on invalidating
2014 * locally cached WWPNs (and other N_Port parameters) of gone
2015 * target ports. So, our heroic attempt to make things safe
2016 * could be undermined by 'open port' response data tagged with
2017 * obsolete WWPNs. Another reason to monitor potential
2018 * connection closures ourself at least (by interpreting
2019 * incoming ELS' and unsolicited status). It just crosses my
2020 * mind that one should be able to cross-check by means of
2021 * another GID_PN straight after a port has been opened.
2022 * Alternately, an ADISC/PDISC ELS should suffice, as well.
2024 plogi
= (struct fsf_plogi
*) fsf_req
->qtcb
->bottom
.support
.els
;
2025 if (!atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN
, &port
->status
))
2027 if (fsf_req
->qtcb
->bottom
.support
.els1_length
<
2028 sizeof (struct fsf_plogi
)) {
2029 /* skip sanity check and assume wwpn is ok */
2031 if (plogi
->serv_param
.wwpn
!= port
->wwpn
) {
2033 ZFCP_STATUS_PORT_DID_DID
,
2036 port
->wwnn
= plogi
->serv_param
.wwnn
;
2037 zfcp_fc_plogi_evaluate(port
, plogi
);
2043 case FSF_UNKNOWN_OP_SUBTYPE
:
2044 /* should never occure, subtype not set in zfcp_fsf_open_port */
2045 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2053 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING
, &port
->status
);
2058 * function: zfcp_fsf_close_port
2060 * purpose: submit FSF command "close port"
2062 * returns: address of initiated FSF request
2063 * NULL - request could not be initiated
2066 zfcp_fsf_close_port(struct zfcp_erp_action
*erp_action
)
2068 volatile struct qdio_buffer_element
*sbale
;
2069 struct zfcp_fsf_req
*fsf_req
;
2070 unsigned long lock_flags
;
2073 /* setup new FSF request */
2074 retval
= zfcp_fsf_req_create(erp_action
->adapter
,
2075 FSF_QTCB_CLOSE_PORT
,
2076 ZFCP_WAIT_FOR_SBAL
| ZFCP_REQ_AUTO_CLEANUP
,
2077 erp_action
->adapter
->pool
.fsf_req_erp
,
2078 &lock_flags
, &fsf_req
);
2082 sbale
= zfcp_qdio_sbale_req(fsf_req
);
2083 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
2084 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
2086 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING
, &erp_action
->port
->status
);
2087 fsf_req
->data
= (unsigned long) erp_action
->port
;
2088 fsf_req
->erp_action
= erp_action
;
2089 fsf_req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
2090 fsf_req
->erp_action
= erp_action
;
2091 erp_action
->fsf_req
= fsf_req
;
2093 zfcp_erp_start_timer(fsf_req
);
2094 retval
= zfcp_fsf_req_send(fsf_req
);
2096 zfcp_fsf_req_free(fsf_req
);
2097 erp_action
->fsf_req
= NULL
;
2102 write_unlock_irqrestore(&erp_action
->adapter
->req_q
.lock
, lock_flags
);
2107 * function: zfcp_fsf_close_port_handler
2109 * purpose: is called for finished Close Port FSF command
2114 zfcp_fsf_close_port_handler(struct zfcp_fsf_req
*fsf_req
)
2116 int retval
= -EINVAL
;
2117 struct zfcp_port
*port
;
2119 port
= (struct zfcp_port
*) fsf_req
->data
;
2121 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
2122 /* don't change port status in our bookkeeping */
2123 goto skip_fsfstatus
;
2126 /* evaluate FSF status in QTCB */
2127 switch (fsf_req
->qtcb
->header
.fsf_status
) {
2129 case FSF_PORT_HANDLE_NOT_VALID
:
2130 zfcp_erp_adapter_reopen(port
->adapter
, 0, 107, fsf_req
);
2131 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2134 case FSF_ADAPTER_STATUS_AVAILABLE
:
2135 /* Note: FSF has actually closed the port in this case.
2136 * The status code is just daft. Fingers crossed for a change
2142 zfcp_erp_modify_port_status(port
, 33, fsf_req
,
2143 ZFCP_STATUS_COMMON_OPEN
,
2150 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING
, &port
->status
);
2155 * function: zfcp_fsf_close_physical_port
2157 * purpose: submit FSF command "close physical port"
2159 * returns: address of initiated FSF request
2160 * NULL - request could not be initiated
2163 zfcp_fsf_close_physical_port(struct zfcp_erp_action
*erp_action
)
2165 volatile struct qdio_buffer_element
*sbale
;
2166 struct zfcp_fsf_req
*fsf_req
;
2167 unsigned long lock_flags
;
2170 /* setup new FSF request */
2171 retval
= zfcp_fsf_req_create(erp_action
->adapter
,
2172 FSF_QTCB_CLOSE_PHYSICAL_PORT
,
2173 ZFCP_WAIT_FOR_SBAL
| ZFCP_REQ_AUTO_CLEANUP
,
2174 erp_action
->adapter
->pool
.fsf_req_erp
,
2175 &lock_flags
, &fsf_req
);
2179 sbale
= zfcp_qdio_sbale_req(fsf_req
);
2180 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
2181 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
2183 /* mark port as being closed */
2184 atomic_set_mask(ZFCP_STATUS_PORT_PHYS_CLOSING
,
2185 &erp_action
->port
->status
);
2186 /* save a pointer to this port */
2187 fsf_req
->data
= (unsigned long) erp_action
->port
;
2188 fsf_req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
2189 fsf_req
->erp_action
= erp_action
;
2190 erp_action
->fsf_req
= fsf_req
;
2192 zfcp_erp_start_timer(fsf_req
);
2193 retval
= zfcp_fsf_req_send(fsf_req
);
2195 zfcp_fsf_req_free(fsf_req
);
2196 erp_action
->fsf_req
= NULL
;
2201 write_unlock_irqrestore(&erp_action
->adapter
->req_q
.lock
, lock_flags
);
2206 * function: zfcp_fsf_close_physical_port_handler
2208 * purpose: is called for finished Close Physical Port FSF command
2213 zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req
*fsf_req
)
2215 int retval
= -EINVAL
;
2216 struct zfcp_port
*port
;
2217 struct zfcp_unit
*unit
;
2218 struct fsf_qtcb_header
*header
;
2220 port
= (struct zfcp_port
*) fsf_req
->data
;
2221 header
= &fsf_req
->qtcb
->header
;
2223 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
2224 /* don't change port status in our bookkeeping */
2225 goto skip_fsfstatus
;
2228 /* evaluate FSF status in QTCB */
2229 switch (header
->fsf_status
) {
2231 case FSF_PORT_HANDLE_NOT_VALID
:
2232 zfcp_erp_adapter_reopen(port
->adapter
, 0, 108, fsf_req
);
2233 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2236 case FSF_ACCESS_DENIED
:
2237 zfcp_fsf_access_denied_port(fsf_req
, port
);
2240 case FSF_PORT_BOXED
:
2241 zfcp_erp_port_boxed(port
, 50, fsf_req
);
2242 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
|
2243 ZFCP_STATUS_FSFREQ_RETRY
;
2245 /* can't use generic zfcp_erp_modify_port_status because
2246 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
2247 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
2248 list_for_each_entry(unit
, &port
->unit_list_head
, list
)
2249 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN
,
2253 case FSF_ADAPTER_STATUS_AVAILABLE
:
2254 switch (header
->fsf_status_qual
.word
[0]) {
2255 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
2256 /* This will now be escalated by ERP */
2257 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2259 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
2260 /* ERP strategy will escalate */
2261 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2267 /* can't use generic zfcp_erp_modify_port_status because
2268 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
2270 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN
, &port
->status
);
2271 list_for_each_entry(unit
, &port
->unit_list_head
, list
)
2272 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN
, &unit
->status
);
2278 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_CLOSING
, &port
->status
);
2283 * function: zfcp_fsf_open_unit
2289 * assumptions: This routine does not check whether the associated
2290 * remote port has already been opened. This should be
2291 * done by calling routines. Otherwise some status
2292 * may be presented by FSF
2295 zfcp_fsf_open_unit(struct zfcp_erp_action
*erp_action
)
2297 volatile struct qdio_buffer_element
*sbale
;
2298 struct zfcp_fsf_req
*fsf_req
;
2299 unsigned long lock_flags
;
2302 /* setup new FSF request */
2303 retval
= zfcp_fsf_req_create(erp_action
->adapter
,
2305 ZFCP_WAIT_FOR_SBAL
| ZFCP_REQ_AUTO_CLEANUP
,
2306 erp_action
->adapter
->pool
.fsf_req_erp
,
2307 &lock_flags
, &fsf_req
);
2311 sbale
= zfcp_qdio_sbale_req(fsf_req
);
2312 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
2313 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
2315 fsf_req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
2316 fsf_req
->qtcb
->bottom
.support
.fcp_lun
= erp_action
->unit
->fcp_lun
;
2317 if (!(erp_action
->adapter
->connection_features
& FSF_FEATURE_NPIV_MODE
))
2318 fsf_req
->qtcb
->bottom
.support
.option
=
2319 FSF_OPEN_LUN_SUPPRESS_BOXING
;
2320 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING
, &erp_action
->unit
->status
);
2321 fsf_req
->data
= (unsigned long) erp_action
->unit
;
2322 fsf_req
->erp_action
= erp_action
;
2323 erp_action
->fsf_req
= fsf_req
;
2325 zfcp_erp_start_timer(fsf_req
);
2326 retval
= zfcp_fsf_req_send(erp_action
->fsf_req
);
2328 zfcp_fsf_req_free(fsf_req
);
2329 erp_action
->fsf_req
= NULL
;
2333 write_unlock_irqrestore(&erp_action
->adapter
->req_q
.lock
, lock_flags
);
2338 * function: zfcp_fsf_open_unit_handler
2340 * purpose: is called for finished Open LUN command
2345 zfcp_fsf_open_unit_handler(struct zfcp_fsf_req
*fsf_req
)
2347 int retval
= -EINVAL
;
2348 struct zfcp_adapter
*adapter
;
2349 struct zfcp_unit
*unit
;
2350 struct fsf_qtcb_header
*header
;
2351 struct fsf_qtcb_bottom_support
*bottom
;
2352 struct fsf_queue_designator
*queue_designator
;
2353 int exclusive
, readwrite
;
2355 unit
= (struct zfcp_unit
*) fsf_req
->data
;
2357 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
2358 /* don't change unit status in our bookkeeping */
2359 goto skip_fsfstatus
;
2362 adapter
= fsf_req
->adapter
;
2363 header
= &fsf_req
->qtcb
->header
;
2364 bottom
= &fsf_req
->qtcb
->bottom
.support
;
2365 queue_designator
= &header
->fsf_status_qual
.fsf_queue_designator
;
2367 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED
|
2368 ZFCP_STATUS_COMMON_ACCESS_BOXED
|
2369 ZFCP_STATUS_UNIT_SHARED
|
2370 ZFCP_STATUS_UNIT_READONLY
,
2373 /* evaluate FSF status in QTCB */
2374 switch (header
->fsf_status
) {
2376 case FSF_PORT_HANDLE_NOT_VALID
:
2377 zfcp_erp_adapter_reopen(unit
->port
->adapter
, 0, 109, fsf_req
);
2378 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2381 case FSF_LUN_ALREADY_OPEN
:
2382 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2385 case FSF_ACCESS_DENIED
:
2386 zfcp_fsf_access_denied_unit(fsf_req
, unit
);
2387 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED
, &unit
->status
);
2388 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY
, &unit
->status
);
2391 case FSF_PORT_BOXED
:
2392 zfcp_erp_port_boxed(unit
->port
, 51, fsf_req
);
2393 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
|
2394 ZFCP_STATUS_FSFREQ_RETRY
;
2397 case FSF_LUN_SHARING_VIOLATION
:
2398 if (header
->fsf_status_qual
.word
[0] != 0) {
2399 dev_warn(&adapter
->ccw_device
->dev
,
2400 "FCP-LUN 0x%Lx at the remote port "
2402 "connected to the adapter "
2403 "is already in use in LPAR%d, CSS%d.\n",
2406 queue_designator
->hla
,
2407 queue_designator
->cssid
);
2409 zfcp_act_eval_err(adapter
,
2410 header
->fsf_status_qual
.word
[2]);
2411 zfcp_erp_unit_access_denied(unit
, 60, fsf_req
);
2412 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED
, &unit
->status
);
2413 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY
, &unit
->status
);
2414 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2417 case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED
:
2418 dev_warn(&fsf_req
->adapter
->ccw_device
->dev
,
2419 "The adapter ran out of resources. There is no "
2420 "handle available for unit 0x%016Lx on port 0x%016Lx.",
2421 unit
->fcp_lun
, unit
->port
->wwpn
);
2422 zfcp_erp_unit_failed(unit
, 34, fsf_req
);
2423 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2426 case FSF_ADAPTER_STATUS_AVAILABLE
:
2427 switch (header
->fsf_status_qual
.word
[0]) {
2428 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
2429 /* Re-establish link to port */
2430 zfcp_test_link(unit
->port
);
2431 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2433 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
2434 /* ERP strategy will escalate */
2435 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2440 case FSF_INVALID_COMMAND_OPTION
:
2441 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2446 /* save LUN handle assigned by FSF */
2447 unit
->handle
= header
->lun_handle
;
2448 /* mark unit as open */
2449 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN
, &unit
->status
);
2451 if (!(adapter
->connection_features
& FSF_FEATURE_NPIV_MODE
) &&
2452 (adapter
->adapter_features
& FSF_FEATURE_LUN_SHARING
) &&
2453 (adapter
->ccw_device
->id
.dev_model
!= ZFCP_DEVICE_MODEL_PRIV
)) {
2454 exclusive
= (bottom
->lun_access_info
&
2455 FSF_UNIT_ACCESS_EXCLUSIVE
);
2456 readwrite
= (bottom
->lun_access_info
&
2457 FSF_UNIT_ACCESS_OUTBOUND_TRANSFER
);
2460 atomic_set_mask(ZFCP_STATUS_UNIT_SHARED
,
2464 atomic_set_mask(ZFCP_STATUS_UNIT_READONLY
,
2466 dev_info(&fsf_req
->adapter
->ccw_device
->dev
,
2467 "Read-only access for unit 0x%016Lx "
2468 "on port 0x%016Lx.\n",
2469 unit
->fcp_lun
, unit
->port
->wwpn
);
2472 if (exclusive
&& !readwrite
) {
2473 dev_err(&fsf_req
->adapter
->ccw_device
->dev
,
2474 "Exclusive access of read-only unit "
2475 "0x%016Lx on port 0x%016Lx not "
2476 "supported, disabling unit.\n",
2477 unit
->fcp_lun
, unit
->port
->wwpn
);
2478 zfcp_erp_unit_failed(unit
, 35, fsf_req
);
2479 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2480 zfcp_erp_unit_shutdown(unit
, 0, 80, fsf_req
);
2481 } else if (!exclusive
&& readwrite
) {
2482 dev_err(&fsf_req
->adapter
->ccw_device
->dev
,
2483 "Shared access of read-write unit "
2484 "0x%016Lx on port 0x%016Lx not "
2485 "supported, disabling unit.\n",
2486 unit
->fcp_lun
, unit
->port
->wwpn
);
2487 zfcp_erp_unit_failed(unit
, 36, fsf_req
);
2488 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2489 zfcp_erp_unit_shutdown(unit
, 0, 81, fsf_req
);
2498 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING
, &unit
->status
);
2503 * function: zfcp_fsf_close_unit
2507 * returns: address of fsf_req - request successfully initiated
2510 * assumptions: This routine does not check whether the associated
2511 * remote port/lun has already been opened. This should be
2512 * done by calling routines. Otherwise some status
2513 * may be presented by FSF
2516 zfcp_fsf_close_unit(struct zfcp_erp_action
*erp_action
)
2518 volatile struct qdio_buffer_element
*sbale
;
2519 struct zfcp_fsf_req
*fsf_req
;
2520 unsigned long lock_flags
;
2523 /* setup new FSF request */
2524 retval
= zfcp_fsf_req_create(erp_action
->adapter
,
2526 ZFCP_WAIT_FOR_SBAL
| ZFCP_REQ_AUTO_CLEANUP
,
2527 erp_action
->adapter
->pool
.fsf_req_erp
,
2528 &lock_flags
, &fsf_req
);
2532 sbale
= zfcp_qdio_sbale_req(fsf_req
);
2533 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_READ
;
2534 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
2536 fsf_req
->qtcb
->header
.port_handle
= erp_action
->port
->handle
;
2537 fsf_req
->qtcb
->header
.lun_handle
= erp_action
->unit
->handle
;
2538 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING
, &erp_action
->unit
->status
);
2539 fsf_req
->data
= (unsigned long) erp_action
->unit
;
2540 fsf_req
->erp_action
= erp_action
;
2541 erp_action
->fsf_req
= fsf_req
;
2543 zfcp_erp_start_timer(fsf_req
);
2544 retval
= zfcp_fsf_req_send(erp_action
->fsf_req
);
2546 zfcp_fsf_req_free(fsf_req
);
2547 erp_action
->fsf_req
= NULL
;
2552 write_unlock_irqrestore(&erp_action
->adapter
->req_q
.lock
, lock_flags
);
2557 * function: zfcp_fsf_close_unit_handler
2559 * purpose: is called for finished Close LUN FSF command
2564 zfcp_fsf_close_unit_handler(struct zfcp_fsf_req
*fsf_req
)
2566 int retval
= -EINVAL
;
2567 struct zfcp_unit
*unit
;
2569 unit
= (struct zfcp_unit
*) fsf_req
->data
;
2571 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
2572 /* don't change unit status in our bookkeeping */
2573 goto skip_fsfstatus
;
2576 /* evaluate FSF status in QTCB */
2577 switch (fsf_req
->qtcb
->header
.fsf_status
) {
2579 case FSF_PORT_HANDLE_NOT_VALID
:
2580 zfcp_erp_adapter_reopen(unit
->port
->adapter
, 0, 110, fsf_req
);
2581 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2584 case FSF_LUN_HANDLE_NOT_VALID
:
2585 zfcp_erp_port_reopen(unit
->port
, 0, 111, fsf_req
);
2586 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2589 case FSF_PORT_BOXED
:
2590 zfcp_erp_port_boxed(unit
->port
, 52, fsf_req
);
2591 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
|
2592 ZFCP_STATUS_FSFREQ_RETRY
;
2595 case FSF_ADAPTER_STATUS_AVAILABLE
:
2596 switch (fsf_req
->qtcb
->header
.fsf_status_qual
.word
[0]) {
2597 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
2598 /* re-establish link to port */
2599 zfcp_test_link(unit
->port
);
2600 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2602 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
2603 /* ERP strategy will escalate */
2604 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2612 /* mark unit as closed */
2613 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN
, &unit
->status
);
2619 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING
, &unit
->status
);
2624 * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
2625 * @adapter: adapter where scsi command is issued
2626 * @unit: unit where command is sent to
2627 * @scsi_cmnd: scsi command to be sent
2628 * @timer: timer to be started when request is initiated
2629 * @req_flags: flags for fsf_request
2632 zfcp_fsf_send_fcp_command_task(struct zfcp_adapter
*adapter
,
2633 struct zfcp_unit
*unit
,
2634 struct scsi_cmnd
* scsi_cmnd
,
2635 int use_timer
, int req_flags
)
2637 struct zfcp_fsf_req
*fsf_req
= NULL
;
2638 struct fcp_cmnd_iu
*fcp_cmnd_iu
;
2639 unsigned int sbtype
;
2640 unsigned long lock_flags
;
2645 /* setup new FSF request */
2646 retval
= zfcp_fsf_req_create(adapter
, FSF_QTCB_FCP_CMND
, req_flags
,
2647 adapter
->pool
.fsf_req_scsi
,
2648 &lock_flags
, &fsf_req
);
2649 if (unlikely(retval
< 0))
2650 goto failed_req_create
;
2652 if (unlikely(!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
,
2658 zfcp_unit_get(unit
);
2659 fsf_req
->unit
= unit
;
2661 /* associate FSF request with SCSI request (for look up on abort) */
2662 scsi_cmnd
->host_scribble
= (unsigned char *) fsf_req
->req_id
;
2664 /* associate SCSI command with FSF request */
2665 fsf_req
->data
= (unsigned long) scsi_cmnd
;
2667 /* set handles of unit and its parent port in QTCB */
2668 fsf_req
->qtcb
->header
.lun_handle
= unit
->handle
;
2669 fsf_req
->qtcb
->header
.port_handle
= unit
->port
->handle
;
2671 /* FSF does not define the structure of the FCP_CMND IU */
2672 fcp_cmnd_iu
= (struct fcp_cmnd_iu
*)
2673 &(fsf_req
->qtcb
->bottom
.io
.fcp_cmnd
);
2676 * set depending on data direction:
2677 * data direction bits in SBALE (SB Type)
2678 * data direction bits in QTCB
2679 * data direction bits in FCP_CMND IU
2681 switch (scsi_cmnd
->sc_data_direction
) {
2683 fsf_req
->qtcb
->bottom
.io
.data_direction
= FSF_DATADIR_CMND
;
2686 * what is the correct type for commands
2687 * without 'real' data buffers?
2689 sbtype
= SBAL_FLAGS0_TYPE_READ
;
2691 case DMA_FROM_DEVICE
:
2692 fsf_req
->qtcb
->bottom
.io
.data_direction
= FSF_DATADIR_READ
;
2693 sbtype
= SBAL_FLAGS0_TYPE_READ
;
2694 fcp_cmnd_iu
->rddata
= 1;
2697 fsf_req
->qtcb
->bottom
.io
.data_direction
= FSF_DATADIR_WRITE
;
2698 sbtype
= SBAL_FLAGS0_TYPE_WRITE
;
2699 fcp_cmnd_iu
->wddata
= 1;
2701 case DMA_BIDIRECTIONAL
:
2704 * dummy, catch this condition earlier
2705 * in zfcp_scsi_queuecommand
2707 goto failed_scsi_cmnd
;
2710 /* set FC service class in QTCB (3 per default) */
2711 fsf_req
->qtcb
->bottom
.io
.service_class
= ZFCP_FC_SERVICE_CLASS_DEFAULT
;
2713 /* set FCP_LUN in FCP_CMND IU in QTCB */
2714 fcp_cmnd_iu
->fcp_lun
= unit
->fcp_lun
;
2716 mask
= ZFCP_STATUS_UNIT_READONLY
| ZFCP_STATUS_UNIT_SHARED
;
2718 /* set task attributes in FCP_CMND IU in QTCB */
2719 if (likely((scsi_cmnd
->device
->simple_tags
) ||
2720 (atomic_test_mask(mask
, &unit
->status
))))
2721 fcp_cmnd_iu
->task_attribute
= SIMPLE_Q
;
2723 fcp_cmnd_iu
->task_attribute
= UNTAGGED
;
2725 /* set additional length of FCP_CDB in FCP_CMND IU in QTCB, if needed */
2726 if (unlikely(scsi_cmnd
->cmd_len
> FCP_CDB_LENGTH
))
2727 fcp_cmnd_iu
->add_fcp_cdb_length
2728 = (scsi_cmnd
->cmd_len
- FCP_CDB_LENGTH
) >> 2;
2730 * copy SCSI CDB (including additional length, if any) to
2731 * FCP_CDB in FCP_CMND IU in QTCB
2733 memcpy(fcp_cmnd_iu
->fcp_cdb
, scsi_cmnd
->cmnd
, scsi_cmnd
->cmd_len
);
2735 /* FCP CMND IU length in QTCB */
2736 fsf_req
->qtcb
->bottom
.io
.fcp_cmnd_length
=
2737 sizeof (struct fcp_cmnd_iu
) +
2738 fcp_cmnd_iu
->add_fcp_cdb_length
+ sizeof (fcp_dl_t
);
2740 /* generate SBALEs from data buffer */
2741 real_bytes
= zfcp_qdio_sbals_from_sg(fsf_req
, sbtype
,
2742 scsi_sglist(scsi_cmnd
),
2743 ZFCP_MAX_SBALS_PER_REQ
);
2744 if (unlikely(real_bytes
< 0)) {
2745 if (fsf_req
->sbal_number
< ZFCP_MAX_SBALS_PER_REQ
)
2748 dev_err(&adapter
->ccw_device
->dev
,
2749 "SCSI request too large. "
2750 "Shutting down unit 0x%016Lx on port "
2751 "0x%016Lx.\n", unit
->fcp_lun
,
2753 zfcp_erp_unit_shutdown(unit
, 0, 131, fsf_req
);
2759 /* set length of FCP data length in FCP_CMND IU in QTCB */
2760 zfcp_set_fcp_dl(fcp_cmnd_iu
, real_bytes
);
2763 zfcp_fsf_start_timer(fsf_req
, ZFCP_FSF_REQUEST_TIMEOUT
);
2765 retval
= zfcp_fsf_req_send(fsf_req
);
2766 if (unlikely(retval
< 0))
2774 zfcp_unit_put(unit
);
2776 zfcp_fsf_req_free(fsf_req
);
2778 scsi_cmnd
->host_scribble
= NULL
;
2781 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
2785 struct zfcp_fsf_req
*
2786 zfcp_fsf_send_fcp_command_task_management(struct zfcp_adapter
*adapter
,
2787 struct zfcp_unit
*unit
,
2788 u8 tm_flags
, int req_flags
)
2790 struct zfcp_fsf_req
*fsf_req
= NULL
;
2792 struct fcp_cmnd_iu
*fcp_cmnd_iu
;
2793 unsigned long lock_flags
;
2794 volatile struct qdio_buffer_element
*sbale
;
2796 /* setup new FSF request */
2797 retval
= zfcp_fsf_req_create(adapter
, FSF_QTCB_FCP_CMND
, req_flags
,
2798 adapter
->pool
.fsf_req_scsi
,
2799 &lock_flags
, &fsf_req
);
2803 if (unlikely(!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
,
2808 * Used to decide on proper handler in the return path,
2809 * could be either zfcp_fsf_send_fcp_command_task_handler or
2810 * zfcp_fsf_send_fcp_command_task_management_handler */
2812 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT
;
2815 * hold a pointer to the unit being target of this
2816 * task management request
2818 fsf_req
->data
= (unsigned long) unit
;
2820 /* set FSF related fields in QTCB */
2821 fsf_req
->qtcb
->header
.lun_handle
= unit
->handle
;
2822 fsf_req
->qtcb
->header
.port_handle
= unit
->port
->handle
;
2823 fsf_req
->qtcb
->bottom
.io
.data_direction
= FSF_DATADIR_CMND
;
2824 fsf_req
->qtcb
->bottom
.io
.service_class
= ZFCP_FC_SERVICE_CLASS_DEFAULT
;
2825 fsf_req
->qtcb
->bottom
.io
.fcp_cmnd_length
=
2826 sizeof (struct fcp_cmnd_iu
) + sizeof (fcp_dl_t
);
2828 sbale
= zfcp_qdio_sbale_req(fsf_req
);
2829 sbale
[0].flags
|= SBAL_FLAGS0_TYPE_WRITE
;
2830 sbale
[1].flags
|= SBAL_FLAGS_LAST_ENTRY
;
2832 /* set FCP related fields in FCP_CMND IU in QTCB */
2833 fcp_cmnd_iu
= (struct fcp_cmnd_iu
*)
2834 &(fsf_req
->qtcb
->bottom
.io
.fcp_cmnd
);
2835 fcp_cmnd_iu
->fcp_lun
= unit
->fcp_lun
;
2836 fcp_cmnd_iu
->task_management_flags
= tm_flags
;
2838 zfcp_fsf_start_timer(fsf_req
, ZFCP_SCSI_ER_TIMEOUT
);
2839 retval
= zfcp_fsf_req_send(fsf_req
);
2844 zfcp_fsf_req_free(fsf_req
);
2848 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
2852 static void zfcp_fsf_update_lat(struct fsf_latency_record
*lat_rec
, u32 lat
)
2854 lat_rec
->sum
+= lat
;
2855 if (lat_rec
->min
> lat
)
2857 if (lat_rec
->max
< lat
)
2861 static void zfcp_fsf_req_latency(struct zfcp_fsf_req
*fsf_req
)
2863 struct fsf_qual_latency_info
*lat_inf
;
2864 struct latency_cont
*lat
;
2865 struct zfcp_unit
*unit
;
2866 unsigned long flags
;
2868 lat_inf
= &fsf_req
->qtcb
->prefix
.prot_status_qual
.latency_info
;
2869 unit
= fsf_req
->unit
;
2871 switch (fsf_req
->qtcb
->bottom
.io
.data_direction
) {
2872 case FSF_DATADIR_READ
:
2873 lat
= &unit
->latencies
.read
;
2875 case FSF_DATADIR_WRITE
:
2876 lat
= &unit
->latencies
.write
;
2878 case FSF_DATADIR_CMND
:
2879 lat
= &unit
->latencies
.cmd
;
2885 spin_lock_irqsave(&unit
->latencies
.lock
, flags
);
2886 zfcp_fsf_update_lat(&lat
->channel
, lat_inf
->channel_lat
);
2887 zfcp_fsf_update_lat(&lat
->fabric
, lat_inf
->fabric_lat
);
2889 spin_unlock_irqrestore(&unit
->latencies
.lock
, flags
);
2893 * function: zfcp_fsf_send_fcp_command_handler
2895 * purpose: is called for finished Send FCP Command
2900 zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req
*fsf_req
)
2902 int retval
= -EINVAL
;
2903 struct zfcp_unit
*unit
;
2904 struct fsf_qtcb_header
*header
;
2906 header
= &fsf_req
->qtcb
->header
;
2908 if (unlikely(fsf_req
->status
& ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT
))
2909 unit
= (struct zfcp_unit
*) fsf_req
->data
;
2911 unit
= fsf_req
->unit
;
2913 if (unlikely(fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)) {
2914 /* go directly to calls of special handlers */
2915 goto skip_fsfstatus
;
2918 /* evaluate FSF status in QTCB */
2919 switch (header
->fsf_status
) {
2921 case FSF_PORT_HANDLE_NOT_VALID
:
2922 zfcp_erp_adapter_reopen(unit
->port
->adapter
, 0, 112, fsf_req
);
2923 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2926 case FSF_LUN_HANDLE_NOT_VALID
:
2927 zfcp_erp_port_reopen(unit
->port
, 0, 113, fsf_req
);
2928 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2931 case FSF_HANDLE_MISMATCH
:
2932 zfcp_erp_adapter_reopen(unit
->port
->adapter
, 0, 114, fsf_req
);
2933 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2936 case FSF_SERVICE_CLASS_NOT_SUPPORTED
:
2937 zfcp_fsf_class_not_supp(fsf_req
);
2940 case FSF_FCPLUN_NOT_VALID
:
2941 zfcp_erp_port_reopen(unit
->port
, 0, 115, fsf_req
);
2942 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2945 case FSF_ACCESS_DENIED
:
2946 zfcp_fsf_access_denied_unit(fsf_req
, unit
);
2949 case FSF_DIRECTION_INDICATOR_NOT_VALID
:
2950 dev_err(&fsf_req
->adapter
->ccw_device
->dev
,
2951 "Invalid data direction (%d) given for unit 0x%016Lx "
2952 "on port 0x%016Lx, shutting down adapter.\n",
2953 fsf_req
->qtcb
->bottom
.io
.data_direction
,
2954 unit
->fcp_lun
, unit
->port
->wwpn
);
2955 zfcp_erp_adapter_shutdown(unit
->port
->adapter
, 0, 133, fsf_req
);
2956 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2959 case FSF_CMND_LENGTH_NOT_VALID
:
2960 dev_err(&fsf_req
->adapter
->ccw_device
->dev
,
2961 "An invalid control-data-block length field (%d) "
2962 "was found in a command for unit 0x%016Lx on port "
2963 "0x%016Lx. Shutting down adapter.\n",
2964 fsf_req
->qtcb
->bottom
.io
.fcp_cmnd_length
,
2965 unit
->fcp_lun
, unit
->port
->wwpn
);
2966 zfcp_erp_adapter_shutdown(unit
->port
->adapter
, 0, 134, fsf_req
);
2967 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2970 case FSF_PORT_BOXED
:
2971 zfcp_erp_port_boxed(unit
->port
, 53, fsf_req
);
2972 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
|
2973 ZFCP_STATUS_FSFREQ_RETRY
;
2977 zfcp_erp_unit_boxed(unit
, 54, fsf_req
);
2978 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
2979 | ZFCP_STATUS_FSFREQ_RETRY
;
2982 case FSF_ADAPTER_STATUS_AVAILABLE
:
2983 switch (header
->fsf_status_qual
.word
[0]) {
2984 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE
:
2985 /* re-establish link to port */
2986 zfcp_test_link(unit
->port
);
2988 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED
:
2989 /* FIXME(hw) need proper specs for proper action */
2990 /* let scsi stack deal with retries and escalation */
2993 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
2999 case FSF_FCP_RSP_AVAILABLE
:
3004 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT
) {
3006 zfcp_fsf_send_fcp_command_task_management_handler(fsf_req
);
3008 retval
= zfcp_fsf_send_fcp_command_task_handler(fsf_req
);
3009 fsf_req
->unit
= NULL
;
3010 zfcp_unit_put(unit
);
3016 * function: zfcp_fsf_send_fcp_command_task_handler
3018 * purpose: evaluates FCP_RSP IU
3023 zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req
*fsf_req
)
3026 struct scsi_cmnd
*scpnt
;
3027 struct fcp_rsp_iu
*fcp_rsp_iu
= (struct fcp_rsp_iu
*)
3028 &(fsf_req
->qtcb
->bottom
.io
.fcp_rsp
);
3030 char *fcp_rsp_info
= zfcp_get_fcp_rsp_info_ptr(fcp_rsp_iu
);
3031 unsigned long flags
;
3033 read_lock_irqsave(&fsf_req
->adapter
->abort_lock
, flags
);
3034 scpnt
= (struct scsi_cmnd
*) fsf_req
->data
;
3035 if (unlikely(!scpnt
))
3038 if (unlikely(fsf_req
->status
& ZFCP_STATUS_FSFREQ_ABORTED
)) {
3039 /* FIXME: (design) mid-layer should handle DID_ABORT like
3040 * DID_SOFT_ERROR by retrying the request for devices
3041 * that allow retries.
3043 set_host_byte(scpnt
, DID_SOFT_ERROR
);
3044 set_driver_byte(scpnt
, SUGGEST_RETRY
);
3045 goto skip_fsfstatus
;
3048 if (unlikely(fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
)) {
3049 set_host_byte(scpnt
, DID_ERROR
);
3050 goto skip_fsfstatus
;
3053 /* set message byte of result in SCSI command */
3054 set_msg_byte(scpnt
, COMMAND_COMPLETE
);
3057 * copy SCSI status code of FCP_STATUS of FCP_RSP IU to status byte
3058 * of result in SCSI command
3060 scpnt
->result
|= fcp_rsp_iu
->scsi_status
;
3062 if (fsf_req
->adapter
->adapter_features
& FSF_FEATURE_MEASUREMENT_DATA
)
3063 zfcp_fsf_req_latency(fsf_req
);
3065 /* check FCP_RSP_INFO */
3066 if (unlikely(fcp_rsp_iu
->validity
.bits
.fcp_rsp_len_valid
)) {
3067 switch (fcp_rsp_info
[3]) {
3070 set_host_byte(scpnt
, DID_OK
);
3072 case RSP_CODE_LENGTH_MISMATCH
:
3074 set_host_byte(scpnt
, DID_ERROR
);
3075 goto skip_fsfstatus
;
3076 case RSP_CODE_FIELD_INVALID
:
3077 /* driver or hardware bug */
3078 set_host_byte(scpnt
, DID_ERROR
);
3079 goto skip_fsfstatus
;
3080 case RSP_CODE_RO_MISMATCH
:
3082 set_host_byte(scpnt
, DID_ERROR
);
3083 goto skip_fsfstatus
;
3085 /* invalid FCP response code */
3086 set_host_byte(scpnt
, DID_ERROR
);
3087 goto skip_fsfstatus
;
3091 /* check for sense data */
3092 if (unlikely(fcp_rsp_iu
->validity
.bits
.fcp_sns_len_valid
)) {
3093 sns_len
= FSF_FCP_RSP_SIZE
-
3094 sizeof (struct fcp_rsp_iu
) + fcp_rsp_iu
->fcp_rsp_len
;
3095 sns_len
= min(sns_len
, (u32
) SCSI_SENSE_BUFFERSIZE
);
3096 sns_len
= min(sns_len
, fcp_rsp_iu
->fcp_sns_len
);
3098 memcpy(scpnt
->sense_buffer
,
3099 zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu
), sns_len
);
3102 /* check for underrun */
3103 if (unlikely(fcp_rsp_iu
->validity
.bits
.fcp_resid_under
)) {
3104 scsi_set_resid(scpnt
, fcp_rsp_iu
->fcp_resid
);
3105 if (scsi_bufflen(scpnt
) - scsi_get_resid(scpnt
) <
3107 set_host_byte(scpnt
, DID_ERROR
);
3111 if (scpnt
->result
!= 0)
3112 zfcp_scsi_dbf_event_result("erro", 3, fsf_req
->adapter
, scpnt
, fsf_req
);
3113 else if (scpnt
->retries
> 0)
3114 zfcp_scsi_dbf_event_result("retr", 4, fsf_req
->adapter
, scpnt
, fsf_req
);
3116 zfcp_scsi_dbf_event_result("norm", 6, fsf_req
->adapter
, scpnt
, fsf_req
);
3118 /* cleanup pointer (need this especially for abort) */
3119 scpnt
->host_scribble
= NULL
;
3121 /* always call back */
3122 (scpnt
->scsi_done
) (scpnt
);
3125 * We must hold this lock until scsi_done has been called.
3126 * Otherwise we may call scsi_done after abort regarding this
3127 * command has completed.
3128 * Note: scsi_done must not block!
3131 read_unlock_irqrestore(&fsf_req
->adapter
->abort_lock
, flags
);
3136 * function: zfcp_fsf_send_fcp_command_task_management_handler
3138 * purpose: evaluates FCP_RSP IU
3143 zfcp_fsf_send_fcp_command_task_management_handler(struct zfcp_fsf_req
*fsf_req
)
3146 struct fcp_rsp_iu
*fcp_rsp_iu
= (struct fcp_rsp_iu
*)
3147 &(fsf_req
->qtcb
->bottom
.io
.fcp_rsp
);
3148 char *fcp_rsp_info
= zfcp_get_fcp_rsp_info_ptr(fcp_rsp_iu
);
3150 if (fsf_req
->status
& ZFCP_STATUS_FSFREQ_ERROR
) {
3151 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_TMFUNCFAILED
;
3152 goto skip_fsfstatus
;
3155 /* check FCP_RSP_INFO */
3156 switch (fcp_rsp_info
[3]) {
3160 case RSP_CODE_TASKMAN_UNSUPP
:
3161 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP
;
3163 case RSP_CODE_TASKMAN_FAILED
:
3164 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_TMFUNCFAILED
;
3167 /* invalid FCP response code */
3168 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_TMFUNCFAILED
;
3177 * function: zfcp_fsf_control_file
3179 * purpose: Initiator of the control file upload/download FSF requests
3181 * returns: 0 - FSF request is successfuly created and queued
3182 * -EOPNOTSUPP - The FCP adapter does not have Control File support
3183 * -EINVAL - Invalid direction specified
3184 * -ENOMEM - Insufficient memory
3185 * -EPERM - Cannot create FSF request or place it in QDIO queue
3187 struct zfcp_fsf_req
*zfcp_fsf_control_file(struct zfcp_adapter
*adapter
,
3188 struct zfcp_fsf_cfdc
*fsf_cfdc
)
3190 struct zfcp_fsf_req
*fsf_req
;
3191 struct fsf_qtcb_bottom_support
*bottom
;
3192 volatile struct qdio_buffer_element
*sbale
;
3193 unsigned long lock_flags
;
3198 if (!(adapter
->adapter_features
& FSF_FEATURE_CFDC
))
3199 return ERR_PTR(-EOPNOTSUPP
);
3201 switch (fsf_cfdc
->command
) {
3202 case FSF_QTCB_DOWNLOAD_CONTROL_FILE
:
3203 direction
= SBAL_FLAGS0_TYPE_WRITE
;
3205 case FSF_QTCB_UPLOAD_CONTROL_FILE
:
3206 direction
= SBAL_FLAGS0_TYPE_READ
;
3209 return ERR_PTR(-EINVAL
);
3212 retval
= zfcp_fsf_req_create(adapter
, fsf_cfdc
->command
,
3214 NULL
, &lock_flags
, &fsf_req
);
3217 goto unlock_queue_lock
;
3220 sbale
= zfcp_qdio_sbale_req(fsf_req
);
3221 sbale
[0].flags
|= direction
;
3223 bottom
= &fsf_req
->qtcb
->bottom
.support
;
3224 bottom
->operation_subtype
= FSF_CFDC_OPERATION_SUBTYPE
;
3225 bottom
->option
= fsf_cfdc
->option
;
3227 bytes
= zfcp_qdio_sbals_from_sg(fsf_req
, direction
,
3229 ZFCP_MAX_SBALS_PER_REQ
);
3230 if (bytes
!= ZFCP_CFDC_MAX_SIZE
) {
3235 zfcp_fsf_start_timer(fsf_req
, ZFCP_FSF_REQUEST_TIMEOUT
);
3236 retval
= zfcp_fsf_req_send(fsf_req
);
3241 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
3243 wait_event(fsf_req
->completion_wq
,
3244 fsf_req
->status
& ZFCP_STATUS_FSFREQ_COMPLETED
);
3249 zfcp_fsf_req_free(fsf_req
);
3251 write_unlock_irqrestore(&adapter
->req_q
.lock
, lock_flags
);
3252 return ERR_PTR(retval
);
3255 static void zfcp_fsf_control_file_handler(struct zfcp_fsf_req
*fsf_req
)
3257 if (fsf_req
->qtcb
->header
.fsf_status
!= FSF_GOOD
)
3258 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_ERROR
;
3262 zfcp_fsf_req_sbal_check(unsigned long *flags
,
3263 struct zfcp_qdio_queue
*queue
, int needed
)
3265 write_lock_irqsave(&queue
->lock
, *flags
);
3266 if (likely(atomic_read(&queue
->count
) >= needed
))
3268 write_unlock_irqrestore(&queue
->lock
, *flags
);
3273 * set qtcb pointer in fsf_req and initialize QTCB
3276 zfcp_fsf_req_qtcb_init(struct zfcp_fsf_req
*fsf_req
)
3278 if (likely(fsf_req
->qtcb
!= NULL
)) {
3279 fsf_req
->qtcb
->prefix
.req_seq_no
=
3280 fsf_req
->adapter
->fsf_req_seq_no
;
3281 fsf_req
->qtcb
->prefix
.req_id
= fsf_req
->req_id
;
3282 fsf_req
->qtcb
->prefix
.ulp_info
= ZFCP_ULP_INFO_VERSION
;
3283 fsf_req
->qtcb
->prefix
.qtcb_type
=
3284 fsf_qtcb_type
[fsf_req
->fsf_command
];
3285 fsf_req
->qtcb
->prefix
.qtcb_version
= ZFCP_QTCB_VERSION
;
3286 fsf_req
->qtcb
->header
.req_handle
= fsf_req
->req_id
;
3287 fsf_req
->qtcb
->header
.fsf_command
= fsf_req
->fsf_command
;
3292 * zfcp_fsf_req_sbal_get - try to get one SBAL in the request queue
3293 * @adapter: adapter for which request queue is examined
3294 * @req_flags: flags indicating whether to wait for needed SBAL or not
3295 * @lock_flags: lock_flags if queue_lock is taken
3296 * Return: 0 on success, otherwise -EIO, or -ERESTARTSYS
3297 * Locks: lock adapter->req_q->lock on success
3300 zfcp_fsf_req_sbal_get(struct zfcp_adapter
*adapter
, int req_flags
,
3301 unsigned long *lock_flags
)
3304 struct zfcp_qdio_queue
*req_q
= &adapter
->req_q
;
3306 if (unlikely(req_flags
& ZFCP_WAIT_FOR_SBAL
)) {
3307 ret
= wait_event_interruptible_timeout(adapter
->request_wq
,
3308 zfcp_fsf_req_sbal_check(lock_flags
, req_q
, 1),
3314 } else if (!zfcp_fsf_req_sbal_check(lock_flags
, req_q
, 1))
3321 * function: zfcp_fsf_req_create
3323 * purpose: create an FSF request at the specified adapter and
3324 * setup common fields
3326 * returns: -ENOMEM if there was insufficient memory for a request
3327 * -EIO if no qdio buffers could be allocate to the request
3328 * -EINVAL/-EPERM on bug conditions in req_dequeue
3331 * note: The created request is returned by reference.
3333 * locks: lock of concerned request queue must not be held,
3334 * but is held on completion (write, irqsave)
3337 zfcp_fsf_req_create(struct zfcp_adapter
*adapter
, u32 fsf_cmd
, int req_flags
,
3338 mempool_t
*pool
, unsigned long *lock_flags
,
3339 struct zfcp_fsf_req
**fsf_req_p
)
3341 volatile struct qdio_buffer_element
*sbale
;
3342 struct zfcp_fsf_req
*fsf_req
= NULL
;
3344 struct zfcp_qdio_queue
*req_q
= &adapter
->req_q
;
3346 /* allocate new FSF request */
3347 fsf_req
= zfcp_fsf_req_alloc(pool
, req_flags
);
3348 if (unlikely(!fsf_req
)) {
3350 goto failed_fsf_req
;
3353 fsf_req
->adapter
= adapter
;
3354 fsf_req
->fsf_command
= fsf_cmd
;
3355 INIT_LIST_HEAD(&fsf_req
->list
);
3356 init_timer(&fsf_req
->timer
);
3358 /* initialize waitqueue which may be used to wait on
3359 this request completion */
3360 init_waitqueue_head(&fsf_req
->completion_wq
);
3362 ret
= zfcp_fsf_req_sbal_get(adapter
, req_flags
, lock_flags
);
3366 /* this is serialized (we are holding req_queue-lock of adapter) */
3367 if (adapter
->req_no
== 0)
3369 fsf_req
->req_id
= adapter
->req_no
++;
3371 zfcp_fsf_req_qtcb_init(fsf_req
);
3374 * We hold queue_lock here. Check if QDIOUP is set and let request fail
3375 * if it is not set (see also *_open_qdio and *_close_qdio).
3378 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP
, &adapter
->status
)) {
3379 write_unlock_irqrestore(&req_q
->lock
, *lock_flags
);
3384 if (fsf_req
->qtcb
) {
3385 fsf_req
->seq_no
= adapter
->fsf_req_seq_no
;
3386 fsf_req
->qtcb
->prefix
.req_seq_no
= adapter
->fsf_req_seq_no
;
3388 fsf_req
->sbal_number
= 1;
3389 fsf_req
->sbal_first
= req_q
->first
;
3390 fsf_req
->sbal_last
= req_q
->first
;
3391 fsf_req
->sbale_curr
= 1;
3393 if (likely(req_flags
& ZFCP_REQ_AUTO_CLEANUP
)) {
3394 fsf_req
->status
|= ZFCP_STATUS_FSFREQ_CLEANUP
;
3397 sbale
= zfcp_qdio_sbale_req(fsf_req
);
3399 /* setup common SBALE fields */
3400 sbale
[0].addr
= (void *) fsf_req
->req_id
;
3401 sbale
[0].flags
|= SBAL_FLAGS0_COMMAND
;
3402 if (likely(fsf_req
->qtcb
!= NULL
)) {
3403 sbale
[1].addr
= (void *) fsf_req
->qtcb
;
3404 sbale
[1].length
= sizeof(struct fsf_qtcb
);
3410 /* dequeue new FSF request previously enqueued */
3411 zfcp_fsf_req_free(fsf_req
);
3415 write_lock_irqsave(&req_q
->lock
, *lock_flags
);
3417 *fsf_req_p
= fsf_req
;
3422 * function: zfcp_fsf_req_send
3424 * purpose: start transfer of FSF request via QDIO
3426 * returns: 0 - request transfer succesfully started
3427 * !0 - start of request transfer failed
3429 static int zfcp_fsf_req_send(struct zfcp_fsf_req
*fsf_req
)
3431 struct zfcp_adapter
*adapter
;
3432 struct zfcp_qdio_queue
*req_q
;
3433 volatile struct qdio_buffer_element
*sbale
;
3437 adapter
= fsf_req
->adapter
;
3438 req_q
= &adapter
->req_q
;
3440 sbale
= zfcp_qdio_sbale_req(fsf_req
);
3442 /* put allocated FSF request into hash table */
3443 spin_lock(&adapter
->req_list_lock
);
3444 zfcp_reqlist_add(adapter
, fsf_req
);
3445 spin_unlock(&adapter
->req_list_lock
);
3447 inc_seq_no
= (fsf_req
->qtcb
!= NULL
);
3449 fsf_req
->issued
= get_clock();
3451 retval
= zfcp_qdio_send(fsf_req
);
3453 if (unlikely(retval
)) {
3454 /* Queues are down..... */
3455 del_timer(&fsf_req
->timer
);
3456 spin_lock(&adapter
->req_list_lock
);
3457 zfcp_reqlist_remove(adapter
, fsf_req
);
3458 spin_unlock(&adapter
->req_list_lock
);
3459 /* undo changes in request queue made for this request */
3460 atomic_add(fsf_req
->sbal_number
, &req_q
->count
);
3461 req_q
->first
-= fsf_req
->sbal_number
;
3462 req_q
->first
+= QDIO_MAX_BUFFERS_PER_Q
;
3463 req_q
->first
%= QDIO_MAX_BUFFERS_PER_Q
;
3464 zfcp_erp_adapter_reopen(adapter
, 0, 116, fsf_req
);
3468 * increase FSF sequence counter -
3469 * this must only be done for request successfully enqueued to
3470 * QDIO this rejected requests may be cleaned up by calling
3471 * routines resulting in missing sequence counter values
3475 /* Don't increase for unsolicited status */
3477 adapter
->fsf_req_seq_no
++;