2 * ibmvfc.c -- driver for IBM Power Virtual Fibre Channel Adapter
4 * Written By: Brian King <brking@linux.vnet.ibm.com>, IBM Corporation
6 * Copyright (C) IBM Corporation, 2008
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/dmapool.h>
28 #include <linux/delay.h>
29 #include <linux/interrupt.h>
30 #include <linux/kthread.h>
31 #include <linux/slab.h>
34 #include <linux/stringify.h>
35 #include <asm/firmware.h>
38 #include <scsi/scsi.h>
39 #include <scsi/scsi_cmnd.h>
40 #include <scsi/scsi_host.h>
41 #include <scsi/scsi_device.h>
42 #include <scsi/scsi_tcq.h>
43 #include <scsi/scsi_transport_fc.h>
44 #include <scsi/scsi_bsg_fc.h>
47 static unsigned int init_timeout
= IBMVFC_INIT_TIMEOUT
;
48 static unsigned int default_timeout
= IBMVFC_DEFAULT_TIMEOUT
;
49 static unsigned int max_lun
= IBMVFC_MAX_LUN
;
50 static unsigned int max_targets
= IBMVFC_MAX_TARGETS
;
51 static unsigned int max_requests
= IBMVFC_MAX_REQUESTS_DEFAULT
;
52 static unsigned int disc_threads
= IBMVFC_MAX_DISC_THREADS
;
53 static unsigned int ibmvfc_debug
= IBMVFC_DEBUG
;
54 static unsigned int log_level
= IBMVFC_DEFAULT_LOG_LEVEL
;
55 static LIST_HEAD(ibmvfc_head
);
56 static DEFINE_SPINLOCK(ibmvfc_driver_lock
);
57 static struct scsi_transport_template
*ibmvfc_transport_template
;
59 MODULE_DESCRIPTION("IBM Virtual Fibre Channel Driver");
60 MODULE_AUTHOR("Brian King <brking@linux.vnet.ibm.com>");
61 MODULE_LICENSE("GPL");
62 MODULE_VERSION(IBMVFC_DRIVER_VERSION
);
64 module_param_named(init_timeout
, init_timeout
, uint
, S_IRUGO
| S_IWUSR
);
65 MODULE_PARM_DESC(init_timeout
, "Initialization timeout in seconds. "
66 "[Default=" __stringify(IBMVFC_INIT_TIMEOUT
) "]");
67 module_param_named(default_timeout
, default_timeout
, uint
, S_IRUGO
| S_IWUSR
);
68 MODULE_PARM_DESC(default_timeout
,
69 "Default timeout in seconds for initialization and EH commands. "
70 "[Default=" __stringify(IBMVFC_DEFAULT_TIMEOUT
) "]");
71 module_param_named(max_requests
, max_requests
, uint
, S_IRUGO
);
72 MODULE_PARM_DESC(max_requests
, "Maximum requests for this adapter. "
73 "[Default=" __stringify(IBMVFC_MAX_REQUESTS_DEFAULT
) "]");
74 module_param_named(max_lun
, max_lun
, uint
, S_IRUGO
);
75 MODULE_PARM_DESC(max_lun
, "Maximum allowed LUN. "
76 "[Default=" __stringify(IBMVFC_MAX_LUN
) "]");
77 module_param_named(max_targets
, max_targets
, uint
, S_IRUGO
);
78 MODULE_PARM_DESC(max_targets
, "Maximum allowed targets. "
79 "[Default=" __stringify(IBMVFC_MAX_TARGETS
) "]");
80 module_param_named(disc_threads
, disc_threads
, uint
, S_IRUGO
);
81 MODULE_PARM_DESC(disc_threads
, "Number of device discovery threads to use. "
82 "[Default=" __stringify(IBMVFC_MAX_DISC_THREADS
) "]");
83 module_param_named(debug
, ibmvfc_debug
, uint
, S_IRUGO
| S_IWUSR
);
84 MODULE_PARM_DESC(debug
, "Enable driver debug information. "
85 "[Default=" __stringify(IBMVFC_DEBUG
) "]");
86 module_param_named(log_level
, log_level
, uint
, 0);
87 MODULE_PARM_DESC(log_level
, "Set to 0 - 4 for increasing verbosity of device driver. "
88 "[Default=" __stringify(IBMVFC_DEFAULT_LOG_LEVEL
) "]");
98 { IBMVFC_FABRIC_MAPPED
, IBMVFC_UNABLE_TO_ESTABLISH
, DID_ERROR
, 1, 1, "unable to establish" },
99 { IBMVFC_FABRIC_MAPPED
, IBMVFC_XPORT_FAULT
, DID_OK
, 1, 0, "transport fault" },
100 { IBMVFC_FABRIC_MAPPED
, IBMVFC_CMD_TIMEOUT
, DID_TIME_OUT
, 1, 1, "command timeout" },
101 { IBMVFC_FABRIC_MAPPED
, IBMVFC_ENETDOWN
, DID_TRANSPORT_DISRUPTED
, 1, 1, "network down" },
102 { IBMVFC_FABRIC_MAPPED
, IBMVFC_HW_FAILURE
, DID_ERROR
, 1, 1, "hardware failure" },
103 { IBMVFC_FABRIC_MAPPED
, IBMVFC_LINK_DOWN_ERR
, DID_REQUEUE
, 0, 0, "link down" },
104 { IBMVFC_FABRIC_MAPPED
, IBMVFC_LINK_DEAD_ERR
, DID_ERROR
, 0, 0, "link dead" },
105 { IBMVFC_FABRIC_MAPPED
, IBMVFC_UNABLE_TO_REGISTER
, DID_ERROR
, 1, 1, "unable to register" },
106 { IBMVFC_FABRIC_MAPPED
, IBMVFC_XPORT_BUSY
, DID_BUS_BUSY
, 1, 0, "transport busy" },
107 { IBMVFC_FABRIC_MAPPED
, IBMVFC_XPORT_DEAD
, DID_ERROR
, 0, 1, "transport dead" },
108 { IBMVFC_FABRIC_MAPPED
, IBMVFC_CONFIG_ERROR
, DID_ERROR
, 1, 1, "configuration error" },
109 { IBMVFC_FABRIC_MAPPED
, IBMVFC_NAME_SERVER_FAIL
, DID_ERROR
, 1, 1, "name server failure" },
110 { IBMVFC_FABRIC_MAPPED
, IBMVFC_LINK_HALTED
, DID_REQUEUE
, 1, 0, "link halted" },
111 { IBMVFC_FABRIC_MAPPED
, IBMVFC_XPORT_GENERAL
, DID_OK
, 1, 0, "general transport error" },
113 { IBMVFC_VIOS_FAILURE
, IBMVFC_CRQ_FAILURE
, DID_REQUEUE
, 1, 1, "CRQ failure" },
114 { IBMVFC_VIOS_FAILURE
, IBMVFC_SW_FAILURE
, DID_ERROR
, 0, 1, "software failure" },
115 { IBMVFC_VIOS_FAILURE
, IBMVFC_INVALID_PARAMETER
, DID_ERROR
, 0, 1, "invalid parameter" },
116 { IBMVFC_VIOS_FAILURE
, IBMVFC_MISSING_PARAMETER
, DID_ERROR
, 0, 1, "missing parameter" },
117 { IBMVFC_VIOS_FAILURE
, IBMVFC_HOST_IO_BUS
, DID_ERROR
, 1, 1, "host I/O bus failure" },
118 { IBMVFC_VIOS_FAILURE
, IBMVFC_TRANS_CANCELLED
, DID_ERROR
, 0, 1, "transaction cancelled" },
119 { IBMVFC_VIOS_FAILURE
, IBMVFC_TRANS_CANCELLED_IMPLICIT
, DID_ERROR
, 0, 1, "transaction cancelled implicit" },
120 { IBMVFC_VIOS_FAILURE
, IBMVFC_INSUFFICIENT_RESOURCE
, DID_REQUEUE
, 1, 1, "insufficient resources" },
121 { IBMVFC_VIOS_FAILURE
, IBMVFC_PLOGI_REQUIRED
, DID_ERROR
, 0, 1, "port login required" },
122 { IBMVFC_VIOS_FAILURE
, IBMVFC_COMMAND_FAILED
, DID_ERROR
, 1, 1, "command failed" },
124 { IBMVFC_FC_FAILURE
, IBMVFC_INVALID_ELS_CMD_CODE
, DID_ERROR
, 0, 1, "invalid ELS command code" },
125 { IBMVFC_FC_FAILURE
, IBMVFC_INVALID_VERSION
, DID_ERROR
, 0, 1, "invalid version level" },
126 { IBMVFC_FC_FAILURE
, IBMVFC_LOGICAL_ERROR
, DID_ERROR
, 1, 1, "logical error" },
127 { IBMVFC_FC_FAILURE
, IBMVFC_INVALID_CT_IU_SIZE
, DID_ERROR
, 0, 1, "invalid CT_IU size" },
128 { IBMVFC_FC_FAILURE
, IBMVFC_LOGICAL_BUSY
, DID_REQUEUE
, 1, 0, "logical busy" },
129 { IBMVFC_FC_FAILURE
, IBMVFC_PROTOCOL_ERROR
, DID_ERROR
, 1, 1, "protocol error" },
130 { IBMVFC_FC_FAILURE
, IBMVFC_UNABLE_TO_PERFORM_REQ
, DID_ERROR
, 1, 1, "unable to perform request" },
131 { IBMVFC_FC_FAILURE
, IBMVFC_CMD_NOT_SUPPORTED
, DID_ERROR
, 0, 0, "command not supported" },
132 { IBMVFC_FC_FAILURE
, IBMVFC_SERVER_NOT_AVAIL
, DID_ERROR
, 0, 1, "server not available" },
133 { IBMVFC_FC_FAILURE
, IBMVFC_CMD_IN_PROGRESS
, DID_ERROR
, 0, 1, "command already in progress" },
134 { IBMVFC_FC_FAILURE
, IBMVFC_VENDOR_SPECIFIC
, DID_ERROR
, 1, 1, "vendor specific" },
136 { IBMVFC_FC_SCSI_ERROR
, 0, DID_OK
, 1, 0, "SCSI error" },
139 static void ibmvfc_npiv_login(struct ibmvfc_host
*);
140 static void ibmvfc_tgt_send_prli(struct ibmvfc_target
*);
141 static void ibmvfc_tgt_send_plogi(struct ibmvfc_target
*);
142 static void ibmvfc_tgt_query_target(struct ibmvfc_target
*);
143 static void ibmvfc_npiv_logout(struct ibmvfc_host
*);
145 static const char *unknown_error
= "unknown error";
147 #ifdef CONFIG_SCSI_IBMVFC_TRACE
149 * ibmvfc_trc_start - Log a start trace entry
150 * @evt: ibmvfc event struct
153 static void ibmvfc_trc_start(struct ibmvfc_event
*evt
)
155 struct ibmvfc_host
*vhost
= evt
->vhost
;
156 struct ibmvfc_cmd
*vfc_cmd
= &evt
->iu
.cmd
;
157 struct ibmvfc_mad_common
*mad
= &evt
->iu
.mad_common
;
158 struct ibmvfc_trace_entry
*entry
;
160 entry
= &vhost
->trace
[vhost
->trace_index
++];
162 entry
->time
= jiffies
;
163 entry
->fmt
= evt
->crq
.format
;
164 entry
->type
= IBMVFC_TRC_START
;
166 switch (entry
->fmt
) {
167 case IBMVFC_CMD_FORMAT
:
168 entry
->op_code
= vfc_cmd
->iu
.cdb
[0];
169 entry
->scsi_id
= vfc_cmd
->tgt_scsi_id
;
170 entry
->lun
= scsilun_to_int(&vfc_cmd
->iu
.lun
);
171 entry
->tmf_flags
= vfc_cmd
->iu
.tmf_flags
;
172 entry
->u
.start
.xfer_len
= vfc_cmd
->iu
.xfer_len
;
174 case IBMVFC_MAD_FORMAT
:
175 entry
->op_code
= mad
->opcode
;
183 * ibmvfc_trc_end - Log an end trace entry
184 * @evt: ibmvfc event struct
187 static void ibmvfc_trc_end(struct ibmvfc_event
*evt
)
189 struct ibmvfc_host
*vhost
= evt
->vhost
;
190 struct ibmvfc_cmd
*vfc_cmd
= &evt
->xfer_iu
->cmd
;
191 struct ibmvfc_mad_common
*mad
= &evt
->xfer_iu
->mad_common
;
192 struct ibmvfc_trace_entry
*entry
= &vhost
->trace
[vhost
->trace_index
++];
195 entry
->time
= jiffies
;
196 entry
->fmt
= evt
->crq
.format
;
197 entry
->type
= IBMVFC_TRC_END
;
199 switch (entry
->fmt
) {
200 case IBMVFC_CMD_FORMAT
:
201 entry
->op_code
= vfc_cmd
->iu
.cdb
[0];
202 entry
->scsi_id
= vfc_cmd
->tgt_scsi_id
;
203 entry
->lun
= scsilun_to_int(&vfc_cmd
->iu
.lun
);
204 entry
->tmf_flags
= vfc_cmd
->iu
.tmf_flags
;
205 entry
->u
.end
.status
= vfc_cmd
->status
;
206 entry
->u
.end
.error
= vfc_cmd
->error
;
207 entry
->u
.end
.fcp_rsp_flags
= vfc_cmd
->rsp
.flags
;
208 entry
->u
.end
.rsp_code
= vfc_cmd
->rsp
.data
.info
.rsp_code
;
209 entry
->u
.end
.scsi_status
= vfc_cmd
->rsp
.scsi_status
;
211 case IBMVFC_MAD_FORMAT
:
212 entry
->op_code
= mad
->opcode
;
213 entry
->u
.end
.status
= mad
->status
;
222 #define ibmvfc_trc_start(evt) do { } while (0)
223 #define ibmvfc_trc_end(evt) do { } while (0)
227 * ibmvfc_get_err_index - Find the index into cmd_status for the fcp response
228 * @status: status / error class
232 * index into cmd_status / -EINVAL on failure
234 static int ibmvfc_get_err_index(u16 status
, u16 error
)
238 for (i
= 0; i
< ARRAY_SIZE(cmd_status
); i
++)
239 if ((cmd_status
[i
].status
& status
) == cmd_status
[i
].status
&&
240 cmd_status
[i
].error
== error
)
247 * ibmvfc_get_cmd_error - Find the error description for the fcp response
248 * @status: status / error class
252 * error description string
254 static const char *ibmvfc_get_cmd_error(u16 status
, u16 error
)
256 int rc
= ibmvfc_get_err_index(status
, error
);
258 return cmd_status
[rc
].name
;
259 return unknown_error
;
263 * ibmvfc_get_err_result - Find the scsi status to return for the fcp response
264 * @vfc_cmd: ibmvfc command struct
267 * SCSI result value to return for completed command
269 static int ibmvfc_get_err_result(struct ibmvfc_cmd
*vfc_cmd
)
272 struct ibmvfc_fcp_rsp
*rsp
= &vfc_cmd
->rsp
;
273 int fc_rsp_len
= rsp
->fcp_rsp_len
;
275 if ((rsp
->flags
& FCP_RSP_LEN_VALID
) &&
276 ((fc_rsp_len
&& fc_rsp_len
!= 4 && fc_rsp_len
!= 8) ||
277 rsp
->data
.info
.rsp_code
))
278 return DID_ERROR
<< 16;
280 err
= ibmvfc_get_err_index(vfc_cmd
->status
, vfc_cmd
->error
);
282 return rsp
->scsi_status
| (cmd_status
[err
].result
<< 16);
283 return rsp
->scsi_status
| (DID_ERROR
<< 16);
287 * ibmvfc_retry_cmd - Determine if error status is retryable
288 * @status: status / error class
292 * 1 if error should be retried / 0 if it should not
294 static int ibmvfc_retry_cmd(u16 status
, u16 error
)
296 int rc
= ibmvfc_get_err_index(status
, error
);
299 return cmd_status
[rc
].retry
;
303 static const char *unknown_fc_explain
= "unknown fc explain";
305 static const struct {
309 { 0x00, "no additional explanation" },
310 { 0x01, "service parameter error - options" },
311 { 0x03, "service parameter error - initiator control" },
312 { 0x05, "service parameter error - recipient control" },
313 { 0x07, "service parameter error - received data field size" },
314 { 0x09, "service parameter error - concurrent seq" },
315 { 0x0B, "service parameter error - credit" },
316 { 0x0D, "invalid N_Port/F_Port_Name" },
317 { 0x0E, "invalid node/Fabric Name" },
318 { 0x0F, "invalid common service parameters" },
319 { 0x11, "invalid association header" },
320 { 0x13, "association header required" },
321 { 0x15, "invalid originator S_ID" },
322 { 0x17, "invalid OX_ID-RX-ID combination" },
323 { 0x19, "command (request) already in progress" },
324 { 0x1E, "N_Port Login requested" },
325 { 0x1F, "Invalid N_Port_ID" },
328 static const struct {
332 { 0x00, "no additional explanation" },
333 { 0x01, "port identifier not registered" },
334 { 0x02, "port name not registered" },
335 { 0x03, "node name not registered" },
336 { 0x04, "class of service not registered" },
337 { 0x06, "initial process associator not registered" },
338 { 0x07, "FC-4 TYPEs not registered" },
339 { 0x08, "symbolic port name not registered" },
340 { 0x09, "symbolic node name not registered" },
341 { 0x0A, "port type not registered" },
342 { 0xF0, "authorization exception" },
343 { 0xF1, "authentication exception" },
344 { 0xF2, "data base full" },
345 { 0xF3, "data base empty" },
346 { 0xF4, "processing request" },
347 { 0xF5, "unable to verify connection" },
348 { 0xF6, "devices not in a common zone" },
352 * ibmvfc_get_ls_explain - Return the FC Explain description text
353 * @status: FC Explain status
358 static const char *ibmvfc_get_ls_explain(u16 status
)
362 for (i
= 0; i
< ARRAY_SIZE(ls_explain
); i
++)
363 if (ls_explain
[i
].fc_explain
== status
)
364 return ls_explain
[i
].name
;
366 return unknown_fc_explain
;
370 * ibmvfc_get_gs_explain - Return the FC Explain description text
371 * @status: FC Explain status
376 static const char *ibmvfc_get_gs_explain(u16 status
)
380 for (i
= 0; i
< ARRAY_SIZE(gs_explain
); i
++)
381 if (gs_explain
[i
].fc_explain
== status
)
382 return gs_explain
[i
].name
;
384 return unknown_fc_explain
;
387 static const struct {
388 enum ibmvfc_fc_type fc_type
;
391 { IBMVFC_FABRIC_REJECT
, "fabric reject" },
392 { IBMVFC_PORT_REJECT
, "port reject" },
393 { IBMVFC_LS_REJECT
, "ELS reject" },
394 { IBMVFC_FABRIC_BUSY
, "fabric busy" },
395 { IBMVFC_PORT_BUSY
, "port busy" },
396 { IBMVFC_BASIC_REJECT
, "basic reject" },
399 static const char *unknown_fc_type
= "unknown fc type";
402 * ibmvfc_get_fc_type - Return the FC Type description text
403 * @status: FC Type error status
408 static const char *ibmvfc_get_fc_type(u16 status
)
412 for (i
= 0; i
< ARRAY_SIZE(fc_type
); i
++)
413 if (fc_type
[i
].fc_type
== status
)
414 return fc_type
[i
].name
;
416 return unknown_fc_type
;
420 * ibmvfc_set_tgt_action - Set the next init action for the target
421 * @tgt: ibmvfc target struct
422 * @action: action to perform
425 static void ibmvfc_set_tgt_action(struct ibmvfc_target
*tgt
,
426 enum ibmvfc_target_action action
)
428 switch (tgt
->action
) {
429 case IBMVFC_TGT_ACTION_DEL_RPORT
:
430 if (action
== IBMVFC_TGT_ACTION_DELETED_RPORT
)
431 tgt
->action
= action
;
432 case IBMVFC_TGT_ACTION_DELETED_RPORT
:
435 if (action
== IBMVFC_TGT_ACTION_DEL_RPORT
)
437 tgt
->action
= action
;
443 * ibmvfc_set_host_state - Set the state for the host
444 * @vhost: ibmvfc host struct
445 * @state: state to set host to
448 * 0 if state changed / non-zero if not changed
450 static int ibmvfc_set_host_state(struct ibmvfc_host
*vhost
,
451 enum ibmvfc_host_state state
)
455 switch (vhost
->state
) {
456 case IBMVFC_HOST_OFFLINE
:
460 vhost
->state
= state
;
468 * ibmvfc_set_host_action - Set the next init action for the host
469 * @vhost: ibmvfc host struct
470 * @action: action to perform
473 static void ibmvfc_set_host_action(struct ibmvfc_host
*vhost
,
474 enum ibmvfc_host_action action
)
477 case IBMVFC_HOST_ACTION_ALLOC_TGTS
:
478 if (vhost
->action
== IBMVFC_HOST_ACTION_INIT_WAIT
)
479 vhost
->action
= action
;
481 case IBMVFC_HOST_ACTION_LOGO_WAIT
:
482 if (vhost
->action
== IBMVFC_HOST_ACTION_LOGO
)
483 vhost
->action
= action
;
485 case IBMVFC_HOST_ACTION_INIT_WAIT
:
486 if (vhost
->action
== IBMVFC_HOST_ACTION_INIT
)
487 vhost
->action
= action
;
489 case IBMVFC_HOST_ACTION_QUERY
:
490 switch (vhost
->action
) {
491 case IBMVFC_HOST_ACTION_INIT_WAIT
:
492 case IBMVFC_HOST_ACTION_NONE
:
493 case IBMVFC_HOST_ACTION_TGT_DEL_FAILED
:
494 vhost
->action
= action
;
500 case IBMVFC_HOST_ACTION_TGT_INIT
:
501 if (vhost
->action
== IBMVFC_HOST_ACTION_ALLOC_TGTS
)
502 vhost
->action
= action
;
504 case IBMVFC_HOST_ACTION_INIT
:
505 case IBMVFC_HOST_ACTION_TGT_DEL
:
506 switch (vhost
->action
) {
507 case IBMVFC_HOST_ACTION_RESET
:
508 case IBMVFC_HOST_ACTION_REENABLE
:
511 vhost
->action
= action
;
515 case IBMVFC_HOST_ACTION_LOGO
:
516 case IBMVFC_HOST_ACTION_QUERY_TGTS
:
517 case IBMVFC_HOST_ACTION_TGT_DEL_FAILED
:
518 case IBMVFC_HOST_ACTION_NONE
:
519 case IBMVFC_HOST_ACTION_RESET
:
520 case IBMVFC_HOST_ACTION_REENABLE
:
522 vhost
->action
= action
;
528 * ibmvfc_reinit_host - Re-start host initialization (no NPIV Login)
529 * @vhost: ibmvfc host struct
534 static void ibmvfc_reinit_host(struct ibmvfc_host
*vhost
)
536 if (vhost
->action
== IBMVFC_HOST_ACTION_NONE
) {
537 if (!ibmvfc_set_host_state(vhost
, IBMVFC_INITIALIZING
)) {
538 scsi_block_requests(vhost
->host
);
539 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_QUERY
);
544 wake_up(&vhost
->work_wait_q
);
548 * ibmvfc_link_down - Handle a link down event from the adapter
549 * @vhost: ibmvfc host struct
550 * @state: ibmvfc host state to enter
553 static void ibmvfc_link_down(struct ibmvfc_host
*vhost
,
554 enum ibmvfc_host_state state
)
556 struct ibmvfc_target
*tgt
;
559 scsi_block_requests(vhost
->host
);
560 list_for_each_entry(tgt
, &vhost
->targets
, queue
)
561 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
562 ibmvfc_set_host_state(vhost
, state
);
563 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_TGT_DEL
);
564 vhost
->events_to_log
|= IBMVFC_AE_LINKDOWN
;
565 wake_up(&vhost
->work_wait_q
);
570 * ibmvfc_init_host - Start host initialization
571 * @vhost: ibmvfc host struct
576 static void ibmvfc_init_host(struct ibmvfc_host
*vhost
)
578 struct ibmvfc_target
*tgt
;
580 if (vhost
->action
== IBMVFC_HOST_ACTION_INIT_WAIT
) {
581 if (++vhost
->init_retries
> IBMVFC_MAX_HOST_INIT_RETRIES
) {
583 "Host initialization retries exceeded. Taking adapter offline\n");
584 ibmvfc_link_down(vhost
, IBMVFC_HOST_OFFLINE
);
589 if (!ibmvfc_set_host_state(vhost
, IBMVFC_INITIALIZING
)) {
590 memset(vhost
->async_crq
.msgs
, 0, PAGE_SIZE
);
591 vhost
->async_crq
.cur
= 0;
593 list_for_each_entry(tgt
, &vhost
->targets
, queue
)
594 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
595 scsi_block_requests(vhost
->host
);
596 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_INIT
);
597 vhost
->job_step
= ibmvfc_npiv_login
;
598 wake_up(&vhost
->work_wait_q
);
603 * ibmvfc_send_crq - Send a CRQ
604 * @vhost: ibmvfc host struct
605 * @word1: the first 64 bits of the data
606 * @word2: the second 64 bits of the data
609 * 0 on success / other on failure
611 static int ibmvfc_send_crq(struct ibmvfc_host
*vhost
, u64 word1
, u64 word2
)
613 struct vio_dev
*vdev
= to_vio_dev(vhost
->dev
);
614 return plpar_hcall_norets(H_SEND_CRQ
, vdev
->unit_address
, word1
, word2
);
618 * ibmvfc_send_crq_init - Send a CRQ init message
619 * @vhost: ibmvfc host struct
622 * 0 on success / other on failure
624 static int ibmvfc_send_crq_init(struct ibmvfc_host
*vhost
)
626 ibmvfc_dbg(vhost
, "Sending CRQ init\n");
627 return ibmvfc_send_crq(vhost
, 0xC001000000000000LL
, 0);
631 * ibmvfc_send_crq_init_complete - Send a CRQ init complete message
632 * @vhost: ibmvfc host struct
635 * 0 on success / other on failure
637 static int ibmvfc_send_crq_init_complete(struct ibmvfc_host
*vhost
)
639 ibmvfc_dbg(vhost
, "Sending CRQ init complete\n");
640 return ibmvfc_send_crq(vhost
, 0xC002000000000000LL
, 0);
644 * ibmvfc_release_crq_queue - Deallocates data and unregisters CRQ
645 * @vhost: ibmvfc host struct
647 * Frees irq, deallocates a page for messages, unmaps dma, and unregisters
648 * the crq with the hypervisor.
650 static void ibmvfc_release_crq_queue(struct ibmvfc_host
*vhost
)
653 struct vio_dev
*vdev
= to_vio_dev(vhost
->dev
);
654 struct ibmvfc_crq_queue
*crq
= &vhost
->crq
;
656 ibmvfc_dbg(vhost
, "Releasing CRQ\n");
657 free_irq(vdev
->irq
, vhost
);
658 tasklet_kill(&vhost
->tasklet
);
662 rc
= plpar_hcall_norets(H_FREE_CRQ
, vdev
->unit_address
);
663 } while (rc
== H_BUSY
|| H_IS_LONG_BUSY(rc
));
665 vhost
->state
= IBMVFC_NO_CRQ
;
666 vhost
->logged_in
= 0;
667 dma_unmap_single(vhost
->dev
, crq
->msg_token
, PAGE_SIZE
, DMA_BIDIRECTIONAL
);
668 free_page((unsigned long)crq
->msgs
);
672 * ibmvfc_reenable_crq_queue - reenables the CRQ
673 * @vhost: ibmvfc host struct
676 * 0 on success / other on failure
678 static int ibmvfc_reenable_crq_queue(struct ibmvfc_host
*vhost
)
681 struct vio_dev
*vdev
= to_vio_dev(vhost
->dev
);
683 /* Re-enable the CRQ */
687 rc
= plpar_hcall_norets(H_ENABLE_CRQ
, vdev
->unit_address
);
688 } while (rc
== H_IN_PROGRESS
|| rc
== H_BUSY
|| H_IS_LONG_BUSY(rc
));
691 dev_err(vhost
->dev
, "Error enabling adapter (rc=%d)\n", rc
);
697 * ibmvfc_reset_crq - resets a crq after a failure
698 * @vhost: ibmvfc host struct
701 * 0 on success / other on failure
703 static int ibmvfc_reset_crq(struct ibmvfc_host
*vhost
)
707 struct vio_dev
*vdev
= to_vio_dev(vhost
->dev
);
708 struct ibmvfc_crq_queue
*crq
= &vhost
->crq
;
714 rc
= plpar_hcall_norets(H_FREE_CRQ
, vdev
->unit_address
);
715 } while (rc
== H_BUSY
|| H_IS_LONG_BUSY(rc
));
717 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
718 vhost
->state
= IBMVFC_NO_CRQ
;
719 vhost
->logged_in
= 0;
720 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_NONE
);
722 /* Clean out the queue */
723 memset(crq
->msgs
, 0, PAGE_SIZE
);
726 /* And re-open it again */
727 rc
= plpar_hcall_norets(H_REG_CRQ
, vdev
->unit_address
,
728 crq
->msg_token
, PAGE_SIZE
);
731 /* Adapter is good, but other end is not ready */
732 dev_warn(vhost
->dev
, "Partner adapter not ready\n");
734 dev_warn(vhost
->dev
, "Couldn't register crq (rc=%d)\n", rc
);
735 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
741 * ibmvfc_valid_event - Determines if event is valid.
742 * @pool: event_pool that contains the event
743 * @evt: ibmvfc event to be checked for validity
746 * 1 if event is valid / 0 if event is not valid
748 static int ibmvfc_valid_event(struct ibmvfc_event_pool
*pool
,
749 struct ibmvfc_event
*evt
)
751 int index
= evt
- pool
->events
;
752 if (index
< 0 || index
>= pool
->size
) /* outside of bounds */
754 if (evt
!= pool
->events
+ index
) /* unaligned */
760 * ibmvfc_free_event - Free the specified event
761 * @evt: ibmvfc_event to be freed
764 static void ibmvfc_free_event(struct ibmvfc_event
*evt
)
766 struct ibmvfc_host
*vhost
= evt
->vhost
;
767 struct ibmvfc_event_pool
*pool
= &vhost
->pool
;
769 BUG_ON(!ibmvfc_valid_event(pool
, evt
));
770 BUG_ON(atomic_inc_return(&evt
->free
) != 1);
771 list_add_tail(&evt
->queue
, &vhost
->free
);
775 * ibmvfc_scsi_eh_done - EH done function for queuecommand commands
776 * @evt: ibmvfc event struct
778 * This function does not setup any error status, that must be done
779 * before this function gets called.
781 static void ibmvfc_scsi_eh_done(struct ibmvfc_event
*evt
)
783 struct scsi_cmnd
*cmnd
= evt
->cmnd
;
786 scsi_dma_unmap(cmnd
);
787 cmnd
->scsi_done(cmnd
);
791 complete(evt
->eh_comp
);
793 ibmvfc_free_event(evt
);
797 * ibmvfc_fail_request - Fail request with specified error code
798 * @evt: ibmvfc event struct
799 * @error_code: error code to fail request with
804 static void ibmvfc_fail_request(struct ibmvfc_event
*evt
, int error_code
)
807 evt
->cmnd
->result
= (error_code
<< 16);
808 evt
->done
= ibmvfc_scsi_eh_done
;
810 evt
->xfer_iu
->mad_common
.status
= IBMVFC_MAD_DRIVER_FAILED
;
812 list_del(&evt
->queue
);
813 del_timer(&evt
->timer
);
819 * ibmvfc_purge_requests - Our virtual adapter just shut down. Purge any sent requests
820 * @vhost: ibmvfc host struct
821 * @error_code: error code to fail requests with
826 static void ibmvfc_purge_requests(struct ibmvfc_host
*vhost
, int error_code
)
828 struct ibmvfc_event
*evt
, *pos
;
830 ibmvfc_dbg(vhost
, "Purging all requests\n");
831 list_for_each_entry_safe(evt
, pos
, &vhost
->sent
, queue
)
832 ibmvfc_fail_request(evt
, error_code
);
836 * ibmvfc_hard_reset_host - Reset the connection to the server by breaking the CRQ
837 * @vhost: struct ibmvfc host to reset
839 static void ibmvfc_hard_reset_host(struct ibmvfc_host
*vhost
)
841 ibmvfc_purge_requests(vhost
, DID_ERROR
);
842 ibmvfc_link_down(vhost
, IBMVFC_LINK_DOWN
);
843 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_RESET
);
847 * __ibmvfc_reset_host - Reset the connection to the server (no locking)
848 * @vhost: struct ibmvfc host to reset
850 static void __ibmvfc_reset_host(struct ibmvfc_host
*vhost
)
852 if (vhost
->logged_in
&& vhost
->action
!= IBMVFC_HOST_ACTION_LOGO_WAIT
&&
853 !ibmvfc_set_host_state(vhost
, IBMVFC_INITIALIZING
)) {
854 scsi_block_requests(vhost
->host
);
855 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_LOGO
);
856 vhost
->job_step
= ibmvfc_npiv_logout
;
857 wake_up(&vhost
->work_wait_q
);
859 ibmvfc_hard_reset_host(vhost
);
863 * ibmvfc_reset_host - Reset the connection to the server
864 * @vhost: ibmvfc host struct
866 static void ibmvfc_reset_host(struct ibmvfc_host
*vhost
)
870 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
871 __ibmvfc_reset_host(vhost
);
872 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
876 * ibmvfc_retry_host_init - Retry host initialization if allowed
877 * @vhost: ibmvfc host struct
879 * Returns: 1 if init will be retried / 0 if not
882 static int ibmvfc_retry_host_init(struct ibmvfc_host
*vhost
)
886 if (vhost
->action
== IBMVFC_HOST_ACTION_INIT_WAIT
) {
887 vhost
->delay_init
= 1;
888 if (++vhost
->init_retries
> IBMVFC_MAX_HOST_INIT_RETRIES
) {
890 "Host initialization retries exceeded. Taking adapter offline\n");
891 ibmvfc_link_down(vhost
, IBMVFC_HOST_OFFLINE
);
892 } else if (vhost
->init_retries
== IBMVFC_MAX_HOST_INIT_RETRIES
)
893 __ibmvfc_reset_host(vhost
);
895 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_INIT
);
900 wake_up(&vhost
->work_wait_q
);
905 * __ibmvfc_get_target - Find the specified scsi_target (no locking)
906 * @starget: scsi target struct
909 * ibmvfc_target struct / NULL if not found
911 static struct ibmvfc_target
*__ibmvfc_get_target(struct scsi_target
*starget
)
913 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
914 struct ibmvfc_host
*vhost
= shost_priv(shost
);
915 struct ibmvfc_target
*tgt
;
917 list_for_each_entry(tgt
, &vhost
->targets
, queue
)
918 if (tgt
->target_id
== starget
->id
) {
919 kref_get(&tgt
->kref
);
926 * ibmvfc_get_target - Find the specified scsi_target
927 * @starget: scsi target struct
930 * ibmvfc_target struct / NULL if not found
932 static struct ibmvfc_target
*ibmvfc_get_target(struct scsi_target
*starget
)
934 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
935 struct ibmvfc_target
*tgt
;
938 spin_lock_irqsave(shost
->host_lock
, flags
);
939 tgt
= __ibmvfc_get_target(starget
);
940 spin_unlock_irqrestore(shost
->host_lock
, flags
);
945 * ibmvfc_get_host_speed - Get host port speed
946 * @shost: scsi host struct
951 static void ibmvfc_get_host_speed(struct Scsi_Host
*shost
)
953 struct ibmvfc_host
*vhost
= shost_priv(shost
);
956 spin_lock_irqsave(shost
->host_lock
, flags
);
957 if (vhost
->state
== IBMVFC_ACTIVE
) {
958 switch (vhost
->login_buf
->resp
.link_speed
/ 100) {
960 fc_host_speed(shost
) = FC_PORTSPEED_1GBIT
;
963 fc_host_speed(shost
) = FC_PORTSPEED_2GBIT
;
966 fc_host_speed(shost
) = FC_PORTSPEED_4GBIT
;
969 fc_host_speed(shost
) = FC_PORTSPEED_8GBIT
;
972 fc_host_speed(shost
) = FC_PORTSPEED_10GBIT
;
975 fc_host_speed(shost
) = FC_PORTSPEED_16GBIT
;
978 ibmvfc_log(vhost
, 3, "Unknown port speed: %lld Gbit\n",
979 vhost
->login_buf
->resp
.link_speed
/ 100);
980 fc_host_speed(shost
) = FC_PORTSPEED_UNKNOWN
;
984 fc_host_speed(shost
) = FC_PORTSPEED_UNKNOWN
;
985 spin_unlock_irqrestore(shost
->host_lock
, flags
);
989 * ibmvfc_get_host_port_state - Get host port state
990 * @shost: scsi host struct
995 static void ibmvfc_get_host_port_state(struct Scsi_Host
*shost
)
997 struct ibmvfc_host
*vhost
= shost_priv(shost
);
1000 spin_lock_irqsave(shost
->host_lock
, flags
);
1001 switch (vhost
->state
) {
1002 case IBMVFC_INITIALIZING
:
1004 fc_host_port_state(shost
) = FC_PORTSTATE_ONLINE
;
1006 case IBMVFC_LINK_DOWN
:
1007 fc_host_port_state(shost
) = FC_PORTSTATE_LINKDOWN
;
1009 case IBMVFC_LINK_DEAD
:
1010 case IBMVFC_HOST_OFFLINE
:
1011 fc_host_port_state(shost
) = FC_PORTSTATE_OFFLINE
;
1014 fc_host_port_state(shost
) = FC_PORTSTATE_BLOCKED
;
1017 fc_host_port_state(shost
) = FC_PORTSTATE_UNKNOWN
;
1020 ibmvfc_log(vhost
, 3, "Unknown port state: %d\n", vhost
->state
);
1021 fc_host_port_state(shost
) = FC_PORTSTATE_UNKNOWN
;
1024 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1028 * ibmvfc_set_rport_dev_loss_tmo - Set rport's device loss timeout
1029 * @rport: rport struct
1030 * @timeout: timeout value
1035 static void ibmvfc_set_rport_dev_loss_tmo(struct fc_rport
*rport
, u32 timeout
)
1038 rport
->dev_loss_tmo
= timeout
;
1040 rport
->dev_loss_tmo
= 1;
1044 * ibmvfc_release_tgt - Free memory allocated for a target
1045 * @kref: kref struct
1048 static void ibmvfc_release_tgt(struct kref
*kref
)
1050 struct ibmvfc_target
*tgt
= container_of(kref
, struct ibmvfc_target
, kref
);
1055 * ibmvfc_get_starget_node_name - Get SCSI target's node name
1056 * @starget: scsi target struct
1061 static void ibmvfc_get_starget_node_name(struct scsi_target
*starget
)
1063 struct ibmvfc_target
*tgt
= ibmvfc_get_target(starget
);
1064 fc_starget_port_name(starget
) = tgt
? tgt
->ids
.node_name
: 0;
1066 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
1070 * ibmvfc_get_starget_port_name - Get SCSI target's port name
1071 * @starget: scsi target struct
1076 static void ibmvfc_get_starget_port_name(struct scsi_target
*starget
)
1078 struct ibmvfc_target
*tgt
= ibmvfc_get_target(starget
);
1079 fc_starget_port_name(starget
) = tgt
? tgt
->ids
.port_name
: 0;
1081 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
1085 * ibmvfc_get_starget_port_id - Get SCSI target's port ID
1086 * @starget: scsi target struct
1091 static void ibmvfc_get_starget_port_id(struct scsi_target
*starget
)
1093 struct ibmvfc_target
*tgt
= ibmvfc_get_target(starget
);
1094 fc_starget_port_id(starget
) = tgt
? tgt
->scsi_id
: -1;
1096 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
1100 * ibmvfc_wait_while_resetting - Wait while the host resets
1101 * @vhost: ibmvfc host struct
1104 * 0 on success / other on failure
1106 static int ibmvfc_wait_while_resetting(struct ibmvfc_host
*vhost
)
1108 long timeout
= wait_event_timeout(vhost
->init_wait_q
,
1109 ((vhost
->state
== IBMVFC_ACTIVE
||
1110 vhost
->state
== IBMVFC_HOST_OFFLINE
||
1111 vhost
->state
== IBMVFC_LINK_DEAD
) &&
1112 vhost
->action
== IBMVFC_HOST_ACTION_NONE
),
1113 (init_timeout
* HZ
));
1115 return timeout
? 0 : -EIO
;
1119 * ibmvfc_issue_fc_host_lip - Re-initiate link initialization
1120 * @shost: scsi host struct
1123 * 0 on success / other on failure
1125 static int ibmvfc_issue_fc_host_lip(struct Scsi_Host
*shost
)
1127 struct ibmvfc_host
*vhost
= shost_priv(shost
);
1129 dev_err(vhost
->dev
, "Initiating host LIP. Resetting connection\n");
1130 ibmvfc_reset_host(vhost
);
1131 return ibmvfc_wait_while_resetting(vhost
);
1135 * ibmvfc_gather_partition_info - Gather info about the LPAR
1140 static void ibmvfc_gather_partition_info(struct ibmvfc_host
*vhost
)
1142 struct device_node
*rootdn
;
1144 const unsigned int *num
;
1146 rootdn
= of_find_node_by_path("/");
1150 name
= of_get_property(rootdn
, "ibm,partition-name", NULL
);
1152 strncpy(vhost
->partition_name
, name
, sizeof(vhost
->partition_name
));
1153 num
= of_get_property(rootdn
, "ibm,partition-no", NULL
);
1155 vhost
->partition_number
= *num
;
1156 of_node_put(rootdn
);
1160 * ibmvfc_set_login_info - Setup info for NPIV login
1161 * @vhost: ibmvfc host struct
1166 static void ibmvfc_set_login_info(struct ibmvfc_host
*vhost
)
1168 struct ibmvfc_npiv_login
*login_info
= &vhost
->login_info
;
1169 struct device_node
*of_node
= vhost
->dev
->of_node
;
1170 const char *location
;
1172 memset(login_info
, 0, sizeof(*login_info
));
1174 login_info
->ostype
= IBMVFC_OS_LINUX
;
1175 login_info
->max_dma_len
= IBMVFC_MAX_SECTORS
<< 9;
1176 login_info
->max_payload
= sizeof(struct ibmvfc_fcp_cmd_iu
);
1177 login_info
->max_response
= sizeof(struct ibmvfc_fcp_rsp
);
1178 login_info
->partition_num
= vhost
->partition_number
;
1179 login_info
->vfc_frame_version
= 1;
1180 login_info
->fcp_version
= 3;
1181 login_info
->flags
= IBMVFC_FLUSH_ON_HALT
;
1182 if (vhost
->client_migrated
)
1183 login_info
->flags
|= IBMVFC_CLIENT_MIGRATED
;
1185 login_info
->max_cmds
= max_requests
+ IBMVFC_NUM_INTERNAL_REQ
;
1186 login_info
->capabilities
= IBMVFC_CAN_MIGRATE
;
1187 login_info
->async
.va
= vhost
->async_crq
.msg_token
;
1188 login_info
->async
.len
= vhost
->async_crq
.size
* sizeof(*vhost
->async_crq
.msgs
);
1189 strncpy(login_info
->partition_name
, vhost
->partition_name
, IBMVFC_MAX_NAME
);
1190 strncpy(login_info
->device_name
,
1191 dev_name(&vhost
->host
->shost_gendev
), IBMVFC_MAX_NAME
);
1193 location
= of_get_property(of_node
, "ibm,loc-code", NULL
);
1194 location
= location
? location
: dev_name(vhost
->dev
);
1195 strncpy(login_info
->drc_name
, location
, IBMVFC_MAX_NAME
);
1199 * ibmvfc_init_event_pool - Allocates and initializes the event pool for a host
1200 * @vhost: ibmvfc host who owns the event pool
1202 * Returns zero on success.
1204 static int ibmvfc_init_event_pool(struct ibmvfc_host
*vhost
)
1207 struct ibmvfc_event_pool
*pool
= &vhost
->pool
;
1210 pool
->size
= max_requests
+ IBMVFC_NUM_INTERNAL_REQ
;
1211 pool
->events
= kcalloc(pool
->size
, sizeof(*pool
->events
), GFP_KERNEL
);
1215 pool
->iu_storage
= dma_alloc_coherent(vhost
->dev
,
1216 pool
->size
* sizeof(*pool
->iu_storage
),
1217 &pool
->iu_token
, 0);
1219 if (!pool
->iu_storage
) {
1220 kfree(pool
->events
);
1224 for (i
= 0; i
< pool
->size
; ++i
) {
1225 struct ibmvfc_event
*evt
= &pool
->events
[i
];
1226 atomic_set(&evt
->free
, 1);
1227 evt
->crq
.valid
= 0x80;
1228 evt
->crq
.ioba
= pool
->iu_token
+ (sizeof(*evt
->xfer_iu
) * i
);
1229 evt
->xfer_iu
= pool
->iu_storage
+ i
;
1231 evt
->ext_list
= NULL
;
1232 list_add_tail(&evt
->queue
, &vhost
->free
);
1240 * ibmvfc_free_event_pool - Frees memory of the event pool of a host
1241 * @vhost: ibmvfc host who owns the event pool
1244 static void ibmvfc_free_event_pool(struct ibmvfc_host
*vhost
)
1247 struct ibmvfc_event_pool
*pool
= &vhost
->pool
;
1250 for (i
= 0; i
< pool
->size
; ++i
) {
1251 list_del(&pool
->events
[i
].queue
);
1252 BUG_ON(atomic_read(&pool
->events
[i
].free
) != 1);
1253 if (pool
->events
[i
].ext_list
)
1254 dma_pool_free(vhost
->sg_pool
,
1255 pool
->events
[i
].ext_list
,
1256 pool
->events
[i
].ext_list_token
);
1259 kfree(pool
->events
);
1260 dma_free_coherent(vhost
->dev
,
1261 pool
->size
* sizeof(*pool
->iu_storage
),
1262 pool
->iu_storage
, pool
->iu_token
);
1267 * ibmvfc_get_event - Gets the next free event in pool
1268 * @vhost: ibmvfc host struct
1270 * Returns a free event from the pool.
1272 static struct ibmvfc_event
*ibmvfc_get_event(struct ibmvfc_host
*vhost
)
1274 struct ibmvfc_event
*evt
;
1276 BUG_ON(list_empty(&vhost
->free
));
1277 evt
= list_entry(vhost
->free
.next
, struct ibmvfc_event
, queue
);
1278 atomic_set(&evt
->free
, 0);
1279 list_del(&evt
->queue
);
1284 * ibmvfc_init_event - Initialize fields in an event struct that are always
1287 * @done: Routine to call when the event is responded to
1288 * @format: SRP or MAD format
1290 static void ibmvfc_init_event(struct ibmvfc_event
*evt
,
1291 void (*done
) (struct ibmvfc_event
*), u8 format
)
1294 evt
->sync_iu
= NULL
;
1295 evt
->crq
.format
= format
;
1297 evt
->eh_comp
= NULL
;
1301 * ibmvfc_map_sg_list - Initialize scatterlist
1302 * @scmd: scsi command struct
1303 * @nseg: number of scatterlist segments
1304 * @md: memory descriptor list to initialize
1306 static void ibmvfc_map_sg_list(struct scsi_cmnd
*scmd
, int nseg
,
1307 struct srp_direct_buf
*md
)
1310 struct scatterlist
*sg
;
1312 scsi_for_each_sg(scmd
, sg
, nseg
, i
) {
1313 md
[i
].va
= sg_dma_address(sg
);
1314 md
[i
].len
= sg_dma_len(sg
);
1320 * ibmvfc_map_sg_data - Maps dma for a scatterlist and initializes decriptor fields
1321 * @scmd: Scsi_Cmnd with the scatterlist
1322 * @evt: ibmvfc event struct
1323 * @vfc_cmd: vfc_cmd that contains the memory descriptor
1324 * @dev: device for which to map dma memory
1327 * 0 on success / non-zero on failure
1329 static int ibmvfc_map_sg_data(struct scsi_cmnd
*scmd
,
1330 struct ibmvfc_event
*evt
,
1331 struct ibmvfc_cmd
*vfc_cmd
, struct device
*dev
)
1335 struct srp_direct_buf
*data
= &vfc_cmd
->ioba
;
1336 struct ibmvfc_host
*vhost
= dev_get_drvdata(dev
);
1338 sg_mapped
= scsi_dma_map(scmd
);
1340 vfc_cmd
->flags
|= IBMVFC_NO_MEM_DESC
;
1342 } else if (unlikely(sg_mapped
< 0)) {
1343 if (vhost
->log_level
> IBMVFC_DEFAULT_LOG_LEVEL
)
1344 scmd_printk(KERN_ERR
, scmd
, "Failed to map DMA buffer for command\n");
1348 if (scmd
->sc_data_direction
== DMA_TO_DEVICE
) {
1349 vfc_cmd
->flags
|= IBMVFC_WRITE
;
1350 vfc_cmd
->iu
.add_cdb_len
|= IBMVFC_WRDATA
;
1352 vfc_cmd
->flags
|= IBMVFC_READ
;
1353 vfc_cmd
->iu
.add_cdb_len
|= IBMVFC_RDDATA
;
1356 if (sg_mapped
== 1) {
1357 ibmvfc_map_sg_list(scmd
, sg_mapped
, data
);
1361 vfc_cmd
->flags
|= IBMVFC_SCATTERLIST
;
1363 if (!evt
->ext_list
) {
1364 evt
->ext_list
= dma_pool_alloc(vhost
->sg_pool
, GFP_ATOMIC
,
1365 &evt
->ext_list_token
);
1367 if (!evt
->ext_list
) {
1368 scsi_dma_unmap(scmd
);
1369 if (vhost
->log_level
> IBMVFC_DEFAULT_LOG_LEVEL
)
1370 scmd_printk(KERN_ERR
, scmd
, "Can't allocate memory for scatterlist\n");
1375 ibmvfc_map_sg_list(scmd
, sg_mapped
, evt
->ext_list
);
1377 data
->va
= evt
->ext_list_token
;
1378 data
->len
= sg_mapped
* sizeof(struct srp_direct_buf
);
1384 * ibmvfc_timeout - Internal command timeout handler
1385 * @evt: struct ibmvfc_event that timed out
1387 * Called when an internally generated command times out
1389 static void ibmvfc_timeout(struct ibmvfc_event
*evt
)
1391 struct ibmvfc_host
*vhost
= evt
->vhost
;
1392 dev_err(vhost
->dev
, "Command timed out (%p). Resetting connection\n", evt
);
1393 ibmvfc_reset_host(vhost
);
1397 * ibmvfc_send_event - Transforms event to u64 array and calls send_crq()
1398 * @evt: event to be sent
1399 * @vhost: ibmvfc host struct
1400 * @timeout: timeout in seconds - 0 means do not time command
1402 * Returns the value returned from ibmvfc_send_crq(). (Zero for success)
1404 static int ibmvfc_send_event(struct ibmvfc_event
*evt
,
1405 struct ibmvfc_host
*vhost
, unsigned long timeout
)
1407 u64
*crq_as_u64
= (u64
*) &evt
->crq
;
1410 /* Copy the IU into the transfer area */
1411 *evt
->xfer_iu
= evt
->iu
;
1412 if (evt
->crq
.format
== IBMVFC_CMD_FORMAT
)
1413 evt
->xfer_iu
->cmd
.tag
= (u64
)evt
;
1414 else if (evt
->crq
.format
== IBMVFC_MAD_FORMAT
)
1415 evt
->xfer_iu
->mad_common
.tag
= (u64
)evt
;
1419 list_add_tail(&evt
->queue
, &vhost
->sent
);
1420 init_timer(&evt
->timer
);
1423 evt
->timer
.data
= (unsigned long) evt
;
1424 evt
->timer
.expires
= jiffies
+ (timeout
* HZ
);
1425 evt
->timer
.function
= (void (*)(unsigned long))ibmvfc_timeout
;
1426 add_timer(&evt
->timer
);
1431 if ((rc
= ibmvfc_send_crq(vhost
, crq_as_u64
[0], crq_as_u64
[1]))) {
1432 list_del(&evt
->queue
);
1433 del_timer(&evt
->timer
);
1435 /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY.
1436 * Firmware will send a CRQ with a transport event (0xFF) to
1437 * tell this client what has happened to the transport. This
1438 * will be handled in ibmvfc_handle_crq()
1440 if (rc
== H_CLOSED
) {
1441 if (printk_ratelimit())
1442 dev_warn(vhost
->dev
, "Send warning. Receive queue closed, will retry.\n");
1444 scsi_dma_unmap(evt
->cmnd
);
1445 ibmvfc_free_event(evt
);
1446 return SCSI_MLQUEUE_HOST_BUSY
;
1449 dev_err(vhost
->dev
, "Send error (rc=%d)\n", rc
);
1451 evt
->cmnd
->result
= DID_ERROR
<< 16;
1452 evt
->done
= ibmvfc_scsi_eh_done
;
1454 evt
->xfer_iu
->mad_common
.status
= IBMVFC_MAD_CRQ_ERROR
;
1458 ibmvfc_trc_start(evt
);
1464 * ibmvfc_log_error - Log an error for the failed command if appropriate
1465 * @evt: ibmvfc event to log
1468 static void ibmvfc_log_error(struct ibmvfc_event
*evt
)
1470 struct ibmvfc_cmd
*vfc_cmd
= &evt
->xfer_iu
->cmd
;
1471 struct ibmvfc_host
*vhost
= evt
->vhost
;
1472 struct ibmvfc_fcp_rsp
*rsp
= &vfc_cmd
->rsp
;
1473 struct scsi_cmnd
*cmnd
= evt
->cmnd
;
1474 const char *err
= unknown_error
;
1475 int index
= ibmvfc_get_err_index(vfc_cmd
->status
, vfc_cmd
->error
);
1480 logerr
= cmd_status
[index
].log
;
1481 err
= cmd_status
[index
].name
;
1484 if (!logerr
&& (vhost
->log_level
<= (IBMVFC_DEFAULT_LOG_LEVEL
+ 1)))
1487 if (rsp
->flags
& FCP_RSP_LEN_VALID
)
1488 rsp_code
= rsp
->data
.info
.rsp_code
;
1490 scmd_printk(KERN_ERR
, cmnd
, "Command (%02X) failed: %s (%x:%x) "
1491 "flags: %x fcp_rsp: %x, resid=%d, scsi_status: %x\n",
1492 cmnd
->cmnd
[0], err
, vfc_cmd
->status
, vfc_cmd
->error
,
1493 rsp
->flags
, rsp_code
, scsi_get_resid(cmnd
), rsp
->scsi_status
);
1497 * ibmvfc_relogin - Log back into the specified device
1498 * @sdev: scsi device struct
1501 static void ibmvfc_relogin(struct scsi_device
*sdev
)
1503 struct ibmvfc_host
*vhost
= shost_priv(sdev
->host
);
1504 struct fc_rport
*rport
= starget_to_rport(scsi_target(sdev
));
1505 struct ibmvfc_target
*tgt
;
1507 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
1508 if (rport
== tgt
->rport
) {
1509 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
1514 ibmvfc_reinit_host(vhost
);
1518 * ibmvfc_scsi_done - Handle responses from commands
1519 * @evt: ibmvfc event to be handled
1521 * Used as a callback when sending scsi cmds.
1523 static void ibmvfc_scsi_done(struct ibmvfc_event
*evt
)
1525 struct ibmvfc_cmd
*vfc_cmd
= &evt
->xfer_iu
->cmd
;
1526 struct ibmvfc_fcp_rsp
*rsp
= &vfc_cmd
->rsp
;
1527 struct scsi_cmnd
*cmnd
= evt
->cmnd
;
1529 u32 sense_len
= rsp
->fcp_sense_len
;
1532 if (vfc_cmd
->response_flags
& IBMVFC_ADAPTER_RESID_VALID
)
1533 scsi_set_resid(cmnd
, vfc_cmd
->adapter_resid
);
1534 else if (rsp
->flags
& FCP_RESID_UNDER
)
1535 scsi_set_resid(cmnd
, rsp
->fcp_resid
);
1537 scsi_set_resid(cmnd
, 0);
1539 if (vfc_cmd
->status
) {
1540 cmnd
->result
= ibmvfc_get_err_result(vfc_cmd
);
1542 if (rsp
->flags
& FCP_RSP_LEN_VALID
)
1543 rsp_len
= rsp
->fcp_rsp_len
;
1544 if ((sense_len
+ rsp_len
) > SCSI_SENSE_BUFFERSIZE
)
1545 sense_len
= SCSI_SENSE_BUFFERSIZE
- rsp_len
;
1546 if ((rsp
->flags
& FCP_SNS_LEN_VALID
) && rsp
->fcp_sense_len
&& rsp_len
<= 8)
1547 memcpy(cmnd
->sense_buffer
, rsp
->data
.sense
+ rsp_len
, sense_len
);
1548 if ((vfc_cmd
->status
& IBMVFC_VIOS_FAILURE
) && (vfc_cmd
->error
== IBMVFC_PLOGI_REQUIRED
))
1549 ibmvfc_relogin(cmnd
->device
);
1551 if (!cmnd
->result
&& (!scsi_get_resid(cmnd
) || (rsp
->flags
& FCP_RESID_OVER
)))
1552 cmnd
->result
= (DID_ERROR
<< 16);
1554 ibmvfc_log_error(evt
);
1557 if (!cmnd
->result
&&
1558 (scsi_bufflen(cmnd
) - scsi_get_resid(cmnd
) < cmnd
->underflow
))
1559 cmnd
->result
= (DID_ERROR
<< 16);
1561 scsi_dma_unmap(cmnd
);
1562 cmnd
->scsi_done(cmnd
);
1566 complete(evt
->eh_comp
);
1568 ibmvfc_free_event(evt
);
1572 * ibmvfc_host_chkready - Check if the host can accept commands
1573 * @vhost: struct ibmvfc host
1576 * 1 if host can accept command / 0 if not
1578 static inline int ibmvfc_host_chkready(struct ibmvfc_host
*vhost
)
1582 switch (vhost
->state
) {
1583 case IBMVFC_LINK_DEAD
:
1584 case IBMVFC_HOST_OFFLINE
:
1585 result
= DID_NO_CONNECT
<< 16;
1588 case IBMVFC_INITIALIZING
:
1590 case IBMVFC_LINK_DOWN
:
1591 result
= DID_REQUEUE
<< 16;
1602 * ibmvfc_queuecommand - The queuecommand function of the scsi template
1603 * @cmnd: struct scsi_cmnd to be executed
1604 * @done: Callback function to be called when cmnd is completed
1607 * 0 on success / other on failure
1609 static int ibmvfc_queuecommand_lck(struct scsi_cmnd
*cmnd
,
1610 void (*done
) (struct scsi_cmnd
*))
1612 struct ibmvfc_host
*vhost
= shost_priv(cmnd
->device
->host
);
1613 struct fc_rport
*rport
= starget_to_rport(scsi_target(cmnd
->device
));
1614 struct ibmvfc_cmd
*vfc_cmd
;
1615 struct ibmvfc_event
*evt
;
1619 if (unlikely((rc
= fc_remote_port_chkready(rport
))) ||
1620 unlikely((rc
= ibmvfc_host_chkready(vhost
)))) {
1626 cmnd
->result
= (DID_OK
<< 16);
1627 evt
= ibmvfc_get_event(vhost
);
1628 ibmvfc_init_event(evt
, ibmvfc_scsi_done
, IBMVFC_CMD_FORMAT
);
1630 cmnd
->scsi_done
= done
;
1631 vfc_cmd
= &evt
->iu
.cmd
;
1632 memset(vfc_cmd
, 0, sizeof(*vfc_cmd
));
1633 vfc_cmd
->resp
.va
= (u64
)evt
->crq
.ioba
+ offsetof(struct ibmvfc_cmd
, rsp
);
1634 vfc_cmd
->resp
.len
= sizeof(vfc_cmd
->rsp
);
1635 vfc_cmd
->frame_type
= IBMVFC_SCSI_FCP_TYPE
;
1636 vfc_cmd
->payload_len
= sizeof(vfc_cmd
->iu
);
1637 vfc_cmd
->resp_len
= sizeof(vfc_cmd
->rsp
);
1638 vfc_cmd
->cancel_key
= (unsigned long)cmnd
->device
->hostdata
;
1639 vfc_cmd
->tgt_scsi_id
= rport
->port_id
;
1640 vfc_cmd
->iu
.xfer_len
= scsi_bufflen(cmnd
);
1641 int_to_scsilun(cmnd
->device
->lun
, &vfc_cmd
->iu
.lun
);
1642 memcpy(vfc_cmd
->iu
.cdb
, cmnd
->cmnd
, cmnd
->cmd_len
);
1644 if (scsi_populate_tag_msg(cmnd
, tag
)) {
1645 vfc_cmd
->task_tag
= tag
[1];
1647 case MSG_SIMPLE_TAG
:
1648 vfc_cmd
->iu
.pri_task_attr
= IBMVFC_SIMPLE_TASK
;
1651 vfc_cmd
->iu
.pri_task_attr
= IBMVFC_HEAD_OF_QUEUE
;
1653 case MSG_ORDERED_TAG
:
1654 vfc_cmd
->iu
.pri_task_attr
= IBMVFC_ORDERED_TASK
;
1659 if (likely(!(rc
= ibmvfc_map_sg_data(cmnd
, evt
, vfc_cmd
, vhost
->dev
))))
1660 return ibmvfc_send_event(evt
, vhost
, 0);
1662 ibmvfc_free_event(evt
);
1664 return SCSI_MLQUEUE_HOST_BUSY
;
1666 if (vhost
->log_level
> IBMVFC_DEFAULT_LOG_LEVEL
)
1667 scmd_printk(KERN_ERR
, cmnd
,
1668 "Failed to map DMA buffer for command. rc=%d\n", rc
);
1670 cmnd
->result
= DID_ERROR
<< 16;
1675 static DEF_SCSI_QCMD(ibmvfc_queuecommand
)
1678 * ibmvfc_sync_completion - Signal that a synchronous command has completed
1679 * @evt: ibmvfc event struct
1682 static void ibmvfc_sync_completion(struct ibmvfc_event
*evt
)
1684 /* copy the response back */
1686 *evt
->sync_iu
= *evt
->xfer_iu
;
1688 complete(&evt
->comp
);
1692 * ibmvfc_bsg_timeout_done - Completion handler for cancelling BSG commands
1693 * @evt: struct ibmvfc_event
1696 static void ibmvfc_bsg_timeout_done(struct ibmvfc_event
*evt
)
1698 struct ibmvfc_host
*vhost
= evt
->vhost
;
1700 ibmvfc_free_event(evt
);
1701 vhost
->aborting_passthru
= 0;
1702 dev_info(vhost
->dev
, "Passthru command cancelled\n");
1706 * ibmvfc_bsg_timeout - Handle a BSG timeout
1707 * @job: struct fc_bsg_job that timed out
1710 * 0 on success / other on failure
1712 static int ibmvfc_bsg_timeout(struct fc_bsg_job
*job
)
1714 struct ibmvfc_host
*vhost
= shost_priv(job
->shost
);
1715 unsigned long port_id
= (unsigned long)job
->dd_data
;
1716 struct ibmvfc_event
*evt
;
1717 struct ibmvfc_tmf
*tmf
;
1718 unsigned long flags
;
1722 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
1723 if (vhost
->aborting_passthru
|| vhost
->state
!= IBMVFC_ACTIVE
) {
1724 __ibmvfc_reset_host(vhost
);
1725 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
1729 vhost
->aborting_passthru
= 1;
1730 evt
= ibmvfc_get_event(vhost
);
1731 ibmvfc_init_event(evt
, ibmvfc_bsg_timeout_done
, IBMVFC_MAD_FORMAT
);
1734 memset(tmf
, 0, sizeof(*tmf
));
1735 tmf
->common
.version
= 1;
1736 tmf
->common
.opcode
= IBMVFC_TMF_MAD
;
1737 tmf
->common
.length
= sizeof(*tmf
);
1738 tmf
->scsi_id
= port_id
;
1739 tmf
->cancel_key
= IBMVFC_PASSTHRU_CANCEL_KEY
;
1740 tmf
->my_cancel_key
= IBMVFC_INTERNAL_CANCEL_KEY
;
1741 rc
= ibmvfc_send_event(evt
, vhost
, default_timeout
);
1744 vhost
->aborting_passthru
= 0;
1745 dev_err(vhost
->dev
, "Failed to send cancel event. rc=%d\n", rc
);
1748 dev_info(vhost
->dev
, "Cancelling passthru command to port id 0x%lx\n",
1751 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
1758 * ibmvfc_bsg_plogi - PLOGI into a target to handle a BSG command
1759 * @vhost: struct ibmvfc_host to send command
1760 * @port_id: port ID to send command
1763 * 0 on success / other on failure
1765 static int ibmvfc_bsg_plogi(struct ibmvfc_host
*vhost
, unsigned int port_id
)
1767 struct ibmvfc_port_login
*plogi
;
1768 struct ibmvfc_target
*tgt
;
1769 struct ibmvfc_event
*evt
;
1770 union ibmvfc_iu rsp_iu
;
1771 unsigned long flags
;
1772 int rc
= 0, issue_login
= 1;
1775 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
1776 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
1777 if (tgt
->scsi_id
== port_id
) {
1785 if (unlikely((rc
= ibmvfc_host_chkready(vhost
))))
1788 evt
= ibmvfc_get_event(vhost
);
1789 ibmvfc_init_event(evt
, ibmvfc_sync_completion
, IBMVFC_MAD_FORMAT
);
1790 plogi
= &evt
->iu
.plogi
;
1791 memset(plogi
, 0, sizeof(*plogi
));
1792 plogi
->common
.version
= 1;
1793 plogi
->common
.opcode
= IBMVFC_PORT_LOGIN
;
1794 plogi
->common
.length
= sizeof(*plogi
);
1795 plogi
->scsi_id
= port_id
;
1796 evt
->sync_iu
= &rsp_iu
;
1797 init_completion(&evt
->comp
);
1799 rc
= ibmvfc_send_event(evt
, vhost
, default_timeout
);
1800 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
1805 wait_for_completion(&evt
->comp
);
1807 if (rsp_iu
.plogi
.common
.status
)
1810 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
1811 ibmvfc_free_event(evt
);
1813 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
1819 * ibmvfc_bsg_request - Handle a BSG request
1820 * @job: struct fc_bsg_job to be executed
1823 * 0 on success / other on failure
1825 static int ibmvfc_bsg_request(struct fc_bsg_job
*job
)
1827 struct ibmvfc_host
*vhost
= shost_priv(job
->shost
);
1828 struct fc_rport
*rport
= job
->rport
;
1829 struct ibmvfc_passthru_mad
*mad
;
1830 struct ibmvfc_event
*evt
;
1831 union ibmvfc_iu rsp_iu
;
1832 unsigned long flags
, port_id
= -1;
1833 unsigned int code
= job
->request
->msgcode
;
1834 int rc
= 0, req_seg
, rsp_seg
, issue_login
= 0;
1835 u32 fc_flags
, rsp_len
;
1838 job
->reply
->reply_payload_rcv_len
= 0;
1840 port_id
= rport
->port_id
;
1843 case FC_BSG_HST_ELS_NOLOGIN
:
1844 port_id
= (job
->request
->rqst_data
.h_els
.port_id
[0] << 16) |
1845 (job
->request
->rqst_data
.h_els
.port_id
[1] << 8) |
1846 job
->request
->rqst_data
.h_els
.port_id
[2];
1847 case FC_BSG_RPT_ELS
:
1848 fc_flags
= IBMVFC_FC_ELS
;
1852 port_id
= (job
->request
->rqst_data
.h_ct
.port_id
[0] << 16) |
1853 (job
->request
->rqst_data
.h_ct
.port_id
[1] << 8) |
1854 job
->request
->rqst_data
.h_ct
.port_id
[2];
1856 fc_flags
= IBMVFC_FC_CT_IU
;
1864 if (!mutex_trylock(&vhost
->passthru_mutex
))
1867 job
->dd_data
= (void *)port_id
;
1868 req_seg
= dma_map_sg(vhost
->dev
, job
->request_payload
.sg_list
,
1869 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
1872 mutex_unlock(&vhost
->passthru_mutex
);
1876 rsp_seg
= dma_map_sg(vhost
->dev
, job
->reply_payload
.sg_list
,
1877 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
1880 dma_unmap_sg(vhost
->dev
, job
->request_payload
.sg_list
,
1881 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
1882 mutex_unlock(&vhost
->passthru_mutex
);
1886 if (req_seg
> 1 || rsp_seg
> 1) {
1892 rc
= ibmvfc_bsg_plogi(vhost
, port_id
);
1894 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
1896 if (unlikely(rc
|| (rport
&& (rc
= fc_remote_port_chkready(rport
)))) ||
1897 unlikely((rc
= ibmvfc_host_chkready(vhost
)))) {
1898 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
1902 evt
= ibmvfc_get_event(vhost
);
1903 ibmvfc_init_event(evt
, ibmvfc_sync_completion
, IBMVFC_MAD_FORMAT
);
1904 mad
= &evt
->iu
.passthru
;
1906 memset(mad
, 0, sizeof(*mad
));
1907 mad
->common
.version
= 1;
1908 mad
->common
.opcode
= IBMVFC_PASSTHRU
;
1909 mad
->common
.length
= sizeof(*mad
) - sizeof(mad
->fc_iu
) - sizeof(mad
->iu
);
1911 mad
->cmd_ioba
.va
= (u64
)evt
->crq
.ioba
+
1912 offsetof(struct ibmvfc_passthru_mad
, iu
);
1913 mad
->cmd_ioba
.len
= sizeof(mad
->iu
);
1915 mad
->iu
.cmd_len
= job
->request_payload
.payload_len
;
1916 mad
->iu
.rsp_len
= job
->reply_payload
.payload_len
;
1917 mad
->iu
.flags
= fc_flags
;
1918 mad
->iu
.cancel_key
= IBMVFC_PASSTHRU_CANCEL_KEY
;
1920 mad
->iu
.cmd
.va
= sg_dma_address(job
->request_payload
.sg_list
);
1921 mad
->iu
.cmd
.len
= sg_dma_len(job
->request_payload
.sg_list
);
1922 mad
->iu
.rsp
.va
= sg_dma_address(job
->reply_payload
.sg_list
);
1923 mad
->iu
.rsp
.len
= sg_dma_len(job
->reply_payload
.sg_list
);
1924 mad
->iu
.scsi_id
= port_id
;
1925 mad
->iu
.tag
= (u64
)evt
;
1926 rsp_len
= mad
->iu
.rsp
.len
;
1928 evt
->sync_iu
= &rsp_iu
;
1929 init_completion(&evt
->comp
);
1930 rc
= ibmvfc_send_event(evt
, vhost
, 0);
1931 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
1938 wait_for_completion(&evt
->comp
);
1940 if (rsp_iu
.passthru
.common
.status
)
1943 job
->reply
->reply_payload_rcv_len
= rsp_len
;
1945 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
1946 ibmvfc_free_event(evt
);
1947 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
1948 job
->reply
->result
= rc
;
1952 dma_unmap_sg(vhost
->dev
, job
->request_payload
.sg_list
,
1953 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
1954 dma_unmap_sg(vhost
->dev
, job
->reply_payload
.sg_list
,
1955 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
1956 mutex_unlock(&vhost
->passthru_mutex
);
1962 * ibmvfc_reset_device - Reset the device with the specified reset type
1963 * @sdev: scsi device to reset
1965 * @desc: reset type description for log messages
1968 * 0 on success / other on failure
1970 static int ibmvfc_reset_device(struct scsi_device
*sdev
, int type
, char *desc
)
1972 struct ibmvfc_host
*vhost
= shost_priv(sdev
->host
);
1973 struct fc_rport
*rport
= starget_to_rport(scsi_target(sdev
));
1974 struct ibmvfc_cmd
*tmf
;
1975 struct ibmvfc_event
*evt
= NULL
;
1976 union ibmvfc_iu rsp_iu
;
1977 struct ibmvfc_fcp_rsp
*fc_rsp
= &rsp_iu
.cmd
.rsp
;
1978 int rsp_rc
= -EBUSY
;
1979 unsigned long flags
;
1982 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
1983 if (vhost
->state
== IBMVFC_ACTIVE
) {
1984 evt
= ibmvfc_get_event(vhost
);
1985 ibmvfc_init_event(evt
, ibmvfc_sync_completion
, IBMVFC_CMD_FORMAT
);
1988 memset(tmf
, 0, sizeof(*tmf
));
1989 tmf
->resp
.va
= (u64
)evt
->crq
.ioba
+ offsetof(struct ibmvfc_cmd
, rsp
);
1990 tmf
->resp
.len
= sizeof(tmf
->rsp
);
1991 tmf
->frame_type
= IBMVFC_SCSI_FCP_TYPE
;
1992 tmf
->payload_len
= sizeof(tmf
->iu
);
1993 tmf
->resp_len
= sizeof(tmf
->rsp
);
1994 tmf
->cancel_key
= (unsigned long)sdev
->hostdata
;
1995 tmf
->tgt_scsi_id
= rport
->port_id
;
1996 int_to_scsilun(sdev
->lun
, &tmf
->iu
.lun
);
1997 tmf
->flags
= (IBMVFC_NO_MEM_DESC
| IBMVFC_TMF
);
1998 tmf
->iu
.tmf_flags
= type
;
1999 evt
->sync_iu
= &rsp_iu
;
2001 init_completion(&evt
->comp
);
2002 rsp_rc
= ibmvfc_send_event(evt
, vhost
, default_timeout
);
2004 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2007 sdev_printk(KERN_ERR
, sdev
, "Failed to send %s reset event. rc=%d\n",
2012 sdev_printk(KERN_INFO
, sdev
, "Resetting %s\n", desc
);
2013 wait_for_completion(&evt
->comp
);
2015 if (rsp_iu
.cmd
.status
)
2016 rsp_code
= ibmvfc_get_err_result(&rsp_iu
.cmd
);
2019 if (fc_rsp
->flags
& FCP_RSP_LEN_VALID
)
2020 rsp_code
= fc_rsp
->data
.info
.rsp_code
;
2022 sdev_printk(KERN_ERR
, sdev
, "%s reset failed: %s (%x:%x) "
2023 "flags: %x fcp_rsp: %x, scsi_status: %x\n",
2024 desc
, ibmvfc_get_cmd_error(rsp_iu
.cmd
.status
, rsp_iu
.cmd
.error
),
2025 rsp_iu
.cmd
.status
, rsp_iu
.cmd
.error
, fc_rsp
->flags
, rsp_code
,
2026 fc_rsp
->scsi_status
);
2029 sdev_printk(KERN_INFO
, sdev
, "%s reset successful\n", desc
);
2031 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
2032 ibmvfc_free_event(evt
);
2033 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2038 * ibmvfc_match_rport - Match function for specified remote port
2039 * @evt: ibmvfc event struct
2040 * @device: device to match (rport)
2043 * 1 if event matches rport / 0 if event does not match rport
2045 static int ibmvfc_match_rport(struct ibmvfc_event
*evt
, void *rport
)
2047 struct fc_rport
*cmd_rport
;
2050 cmd_rport
= starget_to_rport(scsi_target(evt
->cmnd
->device
));
2051 if (cmd_rport
== rport
)
2058 * ibmvfc_match_target - Match function for specified target
2059 * @evt: ibmvfc event struct
2060 * @device: device to match (starget)
2063 * 1 if event matches starget / 0 if event does not match starget
2065 static int ibmvfc_match_target(struct ibmvfc_event
*evt
, void *device
)
2067 if (evt
->cmnd
&& scsi_target(evt
->cmnd
->device
) == device
)
2073 * ibmvfc_match_lun - Match function for specified LUN
2074 * @evt: ibmvfc event struct
2075 * @device: device to match (sdev)
2078 * 1 if event matches sdev / 0 if event does not match sdev
2080 static int ibmvfc_match_lun(struct ibmvfc_event
*evt
, void *device
)
2082 if (evt
->cmnd
&& evt
->cmnd
->device
== device
)
2088 * ibmvfc_wait_for_ops - Wait for ops to complete
2089 * @vhost: ibmvfc host struct
2090 * @device: device to match (starget or sdev)
2091 * @match: match function
2096 static int ibmvfc_wait_for_ops(struct ibmvfc_host
*vhost
, void *device
,
2097 int (*match
) (struct ibmvfc_event
*, void *))
2099 struct ibmvfc_event
*evt
;
2100 DECLARE_COMPLETION_ONSTACK(comp
);
2102 unsigned long flags
;
2103 signed long timeout
= IBMVFC_ABORT_WAIT_TIMEOUT
* HZ
;
2108 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
2109 list_for_each_entry(evt
, &vhost
->sent
, queue
) {
2110 if (match(evt
, device
)) {
2111 evt
->eh_comp
= &comp
;
2115 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2118 timeout
= wait_for_completion_timeout(&comp
, timeout
);
2122 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
2123 list_for_each_entry(evt
, &vhost
->sent
, queue
) {
2124 if (match(evt
, device
)) {
2125 evt
->eh_comp
= NULL
;
2129 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2131 dev_err(vhost
->dev
, "Timed out waiting for aborted commands\n");
2133 return wait
? FAILED
: SUCCESS
;
2143 * ibmvfc_cancel_all - Cancel all outstanding commands to the device
2144 * @sdev: scsi device to cancel commands
2145 * @type: type of error recovery being performed
2147 * This sends a cancel to the VIOS for the specified device. This does
2148 * NOT send any abort to the actual device. That must be done separately.
2151 * 0 on success / other on failure
2153 static int ibmvfc_cancel_all(struct scsi_device
*sdev
, int type
)
2155 struct ibmvfc_host
*vhost
= shost_priv(sdev
->host
);
2156 struct scsi_target
*starget
= scsi_target(sdev
);
2157 struct fc_rport
*rport
= starget_to_rport(starget
);
2158 struct ibmvfc_tmf
*tmf
;
2159 struct ibmvfc_event
*evt
, *found_evt
;
2160 union ibmvfc_iu rsp
;
2161 int rsp_rc
= -EBUSY
;
2162 unsigned long flags
;
2166 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
2168 list_for_each_entry(evt
, &vhost
->sent
, queue
) {
2169 if (evt
->cmnd
&& evt
->cmnd
->device
== sdev
) {
2176 if (vhost
->log_level
> IBMVFC_DEFAULT_LOG_LEVEL
)
2177 sdev_printk(KERN_INFO
, sdev
, "No events found to cancel\n");
2178 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2182 if (vhost
->state
== IBMVFC_ACTIVE
) {
2183 evt
= ibmvfc_get_event(vhost
);
2184 ibmvfc_init_event(evt
, ibmvfc_sync_completion
, IBMVFC_MAD_FORMAT
);
2187 memset(tmf
, 0, sizeof(*tmf
));
2188 tmf
->common
.version
= 1;
2189 tmf
->common
.opcode
= IBMVFC_TMF_MAD
;
2190 tmf
->common
.length
= sizeof(*tmf
);
2191 tmf
->scsi_id
= rport
->port_id
;
2192 int_to_scsilun(sdev
->lun
, &tmf
->lun
);
2193 tmf
->flags
= (type
| IBMVFC_TMF_LUA_VALID
);
2194 tmf
->cancel_key
= (unsigned long)sdev
->hostdata
;
2195 tmf
->my_cancel_key
= (unsigned long)starget
->hostdata
;
2197 evt
->sync_iu
= &rsp
;
2198 init_completion(&evt
->comp
);
2199 rsp_rc
= ibmvfc_send_event(evt
, vhost
, default_timeout
);
2202 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2205 sdev_printk(KERN_ERR
, sdev
, "Failed to send cancel event. rc=%d\n", rsp_rc
);
2209 sdev_printk(KERN_INFO
, sdev
, "Cancelling outstanding commands.\n");
2211 wait_for_completion(&evt
->comp
);
2212 status
= rsp
.mad_common
.status
;
2213 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
2214 ibmvfc_free_event(evt
);
2215 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2217 if (status
!= IBMVFC_MAD_SUCCESS
) {
2218 sdev_printk(KERN_WARNING
, sdev
, "Cancel failed with rc=%x\n", status
);
2222 sdev_printk(KERN_INFO
, sdev
, "Successfully cancelled outstanding commands\n");
2227 * ibmvfc_match_key - Match function for specified cancel key
2228 * @evt: ibmvfc event struct
2229 * @key: cancel key to match
2232 * 1 if event matches key / 0 if event does not match key
2234 static int ibmvfc_match_key(struct ibmvfc_event
*evt
, void *key
)
2236 unsigned long cancel_key
= (unsigned long)key
;
2238 if (evt
->crq
.format
== IBMVFC_CMD_FORMAT
&&
2239 evt
->iu
.cmd
.cancel_key
== cancel_key
)
2245 * ibmvfc_abort_task_set - Abort outstanding commands to the device
2246 * @sdev: scsi device to abort commands
2248 * This sends an Abort Task Set to the VIOS for the specified device. This does
2249 * NOT send any cancel to the VIOS. That must be done separately.
2252 * 0 on success / other on failure
2254 static int ibmvfc_abort_task_set(struct scsi_device
*sdev
)
2256 struct ibmvfc_host
*vhost
= shost_priv(sdev
->host
);
2257 struct fc_rport
*rport
= starget_to_rport(scsi_target(sdev
));
2258 struct ibmvfc_cmd
*tmf
;
2259 struct ibmvfc_event
*evt
, *found_evt
;
2260 union ibmvfc_iu rsp_iu
;
2261 struct ibmvfc_fcp_rsp
*fc_rsp
= &rsp_iu
.cmd
.rsp
;
2262 int rc
, rsp_rc
= -EBUSY
;
2263 unsigned long flags
, timeout
= IBMVFC_ABORT_TIMEOUT
;
2266 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
2268 list_for_each_entry(evt
, &vhost
->sent
, queue
) {
2269 if (evt
->cmnd
&& evt
->cmnd
->device
== sdev
) {
2276 if (vhost
->log_level
> IBMVFC_DEFAULT_LOG_LEVEL
)
2277 sdev_printk(KERN_INFO
, sdev
, "No events found to abort\n");
2278 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2282 if (vhost
->state
== IBMVFC_ACTIVE
) {
2283 evt
= ibmvfc_get_event(vhost
);
2284 ibmvfc_init_event(evt
, ibmvfc_sync_completion
, IBMVFC_CMD_FORMAT
);
2287 memset(tmf
, 0, sizeof(*tmf
));
2288 tmf
->resp
.va
= (u64
)evt
->crq
.ioba
+ offsetof(struct ibmvfc_cmd
, rsp
);
2289 tmf
->resp
.len
= sizeof(tmf
->rsp
);
2290 tmf
->frame_type
= IBMVFC_SCSI_FCP_TYPE
;
2291 tmf
->payload_len
= sizeof(tmf
->iu
);
2292 tmf
->resp_len
= sizeof(tmf
->rsp
);
2293 tmf
->cancel_key
= (unsigned long)sdev
->hostdata
;
2294 tmf
->tgt_scsi_id
= rport
->port_id
;
2295 int_to_scsilun(sdev
->lun
, &tmf
->iu
.lun
);
2296 tmf
->flags
= (IBMVFC_NO_MEM_DESC
| IBMVFC_TMF
);
2297 tmf
->iu
.tmf_flags
= IBMVFC_ABORT_TASK_SET
;
2298 evt
->sync_iu
= &rsp_iu
;
2300 init_completion(&evt
->comp
);
2301 rsp_rc
= ibmvfc_send_event(evt
, vhost
, default_timeout
);
2304 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2307 sdev_printk(KERN_ERR
, sdev
, "Failed to send abort. rc=%d\n", rsp_rc
);
2311 sdev_printk(KERN_INFO
, sdev
, "Aborting outstanding commands\n");
2312 timeout
= wait_for_completion_timeout(&evt
->comp
, timeout
);
2315 rc
= ibmvfc_cancel_all(sdev
, IBMVFC_TMF_ABORT_TASK_SET
);
2317 rc
= ibmvfc_wait_for_ops(vhost
, sdev
->hostdata
, ibmvfc_match_key
);
2323 sdev_printk(KERN_INFO
, sdev
, "Cancel failed, resetting host\n");
2324 ibmvfc_reset_host(vhost
);
2330 if (rsp_iu
.cmd
.status
)
2331 rsp_code
= ibmvfc_get_err_result(&rsp_iu
.cmd
);
2334 if (fc_rsp
->flags
& FCP_RSP_LEN_VALID
)
2335 rsp_code
= fc_rsp
->data
.info
.rsp_code
;
2337 sdev_printk(KERN_ERR
, sdev
, "Abort failed: %s (%x:%x) "
2338 "flags: %x fcp_rsp: %x, scsi_status: %x\n",
2339 ibmvfc_get_cmd_error(rsp_iu
.cmd
.status
, rsp_iu
.cmd
.error
),
2340 rsp_iu
.cmd
.status
, rsp_iu
.cmd
.error
, fc_rsp
->flags
, rsp_code
,
2341 fc_rsp
->scsi_status
);
2344 sdev_printk(KERN_INFO
, sdev
, "Abort successful\n");
2347 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
2348 ibmvfc_free_event(evt
);
2349 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
2354 * ibmvfc_eh_abort_handler - Abort a command
2355 * @cmd: scsi command to abort
2360 static int ibmvfc_eh_abort_handler(struct scsi_cmnd
*cmd
)
2362 struct scsi_device
*sdev
= cmd
->device
;
2363 struct ibmvfc_host
*vhost
= shost_priv(sdev
->host
);
2364 int cancel_rc
, abort_rc
;
2368 fc_block_scsi_eh(cmd
);
2369 ibmvfc_wait_while_resetting(vhost
);
2370 cancel_rc
= ibmvfc_cancel_all(sdev
, IBMVFC_TMF_ABORT_TASK_SET
);
2371 abort_rc
= ibmvfc_abort_task_set(sdev
);
2373 if (!cancel_rc
&& !abort_rc
)
2374 rc
= ibmvfc_wait_for_ops(vhost
, sdev
, ibmvfc_match_lun
);
2381 * ibmvfc_eh_device_reset_handler - Reset a single LUN
2382 * @cmd: scsi command struct
2387 static int ibmvfc_eh_device_reset_handler(struct scsi_cmnd
*cmd
)
2389 struct scsi_device
*sdev
= cmd
->device
;
2390 struct ibmvfc_host
*vhost
= shost_priv(sdev
->host
);
2391 int cancel_rc
, reset_rc
;
2395 fc_block_scsi_eh(cmd
);
2396 ibmvfc_wait_while_resetting(vhost
);
2397 cancel_rc
= ibmvfc_cancel_all(sdev
, IBMVFC_TMF_LUN_RESET
);
2398 reset_rc
= ibmvfc_reset_device(sdev
, IBMVFC_LUN_RESET
, "LUN");
2400 if (!cancel_rc
&& !reset_rc
)
2401 rc
= ibmvfc_wait_for_ops(vhost
, sdev
, ibmvfc_match_lun
);
2408 * ibmvfc_dev_cancel_all_reset - Device iterated cancel all function
2409 * @sdev: scsi device struct
2410 * @data: return code
2413 static void ibmvfc_dev_cancel_all_reset(struct scsi_device
*sdev
, void *data
)
2415 unsigned long *rc
= data
;
2416 *rc
|= ibmvfc_cancel_all(sdev
, IBMVFC_TMF_TGT_RESET
);
2420 * ibmvfc_eh_target_reset_handler - Reset the target
2421 * @cmd: scsi command struct
2426 static int ibmvfc_eh_target_reset_handler(struct scsi_cmnd
*cmd
)
2428 struct scsi_device
*sdev
= cmd
->device
;
2429 struct ibmvfc_host
*vhost
= shost_priv(sdev
->host
);
2430 struct scsi_target
*starget
= scsi_target(sdev
);
2433 unsigned long cancel_rc
= 0;
2436 fc_block_scsi_eh(cmd
);
2437 ibmvfc_wait_while_resetting(vhost
);
2438 starget_for_each_device(starget
, &cancel_rc
, ibmvfc_dev_cancel_all_reset
);
2439 reset_rc
= ibmvfc_reset_device(sdev
, IBMVFC_TARGET_RESET
, "target");
2441 if (!cancel_rc
&& !reset_rc
)
2442 rc
= ibmvfc_wait_for_ops(vhost
, starget
, ibmvfc_match_target
);
2449 * ibmvfc_eh_host_reset_handler - Reset the connection to the server
2450 * @cmd: struct scsi_cmnd having problems
2453 static int ibmvfc_eh_host_reset_handler(struct scsi_cmnd
*cmd
)
2456 struct ibmvfc_host
*vhost
= shost_priv(cmd
->device
->host
);
2458 fc_block_scsi_eh(cmd
);
2459 dev_err(vhost
->dev
, "Resetting connection due to error recovery\n");
2460 rc
= ibmvfc_issue_fc_host_lip(vhost
->host
);
2461 return rc
? FAILED
: SUCCESS
;
2465 * ibmvfc_terminate_rport_io - Terminate all pending I/O to the rport.
2466 * @rport: rport struct
2471 static void ibmvfc_terminate_rport_io(struct fc_rport
*rport
)
2473 struct Scsi_Host
*shost
= rport_to_shost(rport
);
2474 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2475 struct fc_rport
*dev_rport
;
2476 struct scsi_device
*sdev
;
2480 shost_for_each_device(sdev
, shost
) {
2481 dev_rport
= starget_to_rport(scsi_target(sdev
));
2482 if (dev_rport
!= rport
)
2484 ibmvfc_cancel_all(sdev
, IBMVFC_TMF_ABORT_TASK_SET
);
2485 ibmvfc_abort_task_set(sdev
);
2488 rc
= ibmvfc_wait_for_ops(vhost
, rport
, ibmvfc_match_rport
);
2491 ibmvfc_issue_fc_host_lip(shost
);
2495 static const struct ibmvfc_async_desc ae_desc
[] = {
2496 { "PLOGI", IBMVFC_AE_ELS_PLOGI
, IBMVFC_DEFAULT_LOG_LEVEL
+ 1 },
2497 { "LOGO", IBMVFC_AE_ELS_LOGO
, IBMVFC_DEFAULT_LOG_LEVEL
+ 1 },
2498 { "PRLO", IBMVFC_AE_ELS_PRLO
, IBMVFC_DEFAULT_LOG_LEVEL
+ 1 },
2499 { "N-Port SCN", IBMVFC_AE_SCN_NPORT
, IBMVFC_DEFAULT_LOG_LEVEL
+ 1 },
2500 { "Group SCN", IBMVFC_AE_SCN_GROUP
, IBMVFC_DEFAULT_LOG_LEVEL
+ 1 },
2501 { "Domain SCN", IBMVFC_AE_SCN_DOMAIN
, IBMVFC_DEFAULT_LOG_LEVEL
},
2502 { "Fabric SCN", IBMVFC_AE_SCN_FABRIC
, IBMVFC_DEFAULT_LOG_LEVEL
},
2503 { "Link Up", IBMVFC_AE_LINK_UP
, IBMVFC_DEFAULT_LOG_LEVEL
},
2504 { "Link Down", IBMVFC_AE_LINK_DOWN
, IBMVFC_DEFAULT_LOG_LEVEL
},
2505 { "Link Dead", IBMVFC_AE_LINK_DEAD
, IBMVFC_DEFAULT_LOG_LEVEL
},
2506 { "Halt", IBMVFC_AE_HALT
, IBMVFC_DEFAULT_LOG_LEVEL
},
2507 { "Resume", IBMVFC_AE_RESUME
, IBMVFC_DEFAULT_LOG_LEVEL
},
2508 { "Adapter Failed", IBMVFC_AE_ADAPTER_FAILED
, IBMVFC_DEFAULT_LOG_LEVEL
},
2511 static const struct ibmvfc_async_desc unknown_ae
= {
2512 "Unknown async", 0, IBMVFC_DEFAULT_LOG_LEVEL
2516 * ibmvfc_get_ae_desc - Get text description for async event
2520 static const struct ibmvfc_async_desc
*ibmvfc_get_ae_desc(u64 ae
)
2524 for (i
= 0; i
< ARRAY_SIZE(ae_desc
); i
++)
2525 if (ae_desc
[i
].ae
== ae
)
2531 static const struct {
2532 enum ibmvfc_ae_link_state state
;
2535 { IBMVFC_AE_LS_LINK_UP
, " link up" },
2536 { IBMVFC_AE_LS_LINK_BOUNCED
, " link bounced" },
2537 { IBMVFC_AE_LS_LINK_DOWN
, " link down" },
2538 { IBMVFC_AE_LS_LINK_DEAD
, " link dead" },
2542 * ibmvfc_get_link_state - Get text description for link state
2543 * @state: link state
2546 static const char *ibmvfc_get_link_state(enum ibmvfc_ae_link_state state
)
2550 for (i
= 0; i
< ARRAY_SIZE(link_desc
); i
++)
2551 if (link_desc
[i
].state
== state
)
2552 return link_desc
[i
].desc
;
2558 * ibmvfc_handle_async - Handle an async event from the adapter
2559 * @crq: crq to process
2560 * @vhost: ibmvfc host struct
2563 static void ibmvfc_handle_async(struct ibmvfc_async_crq
*crq
,
2564 struct ibmvfc_host
*vhost
)
2566 const struct ibmvfc_async_desc
*desc
= ibmvfc_get_ae_desc(crq
->event
);
2567 struct ibmvfc_target
*tgt
;
2569 ibmvfc_log(vhost
, desc
->log_level
, "%s event received. scsi_id: %llx, wwpn: %llx,"
2570 " node_name: %llx%s\n", desc
->desc
, crq
->scsi_id
, crq
->wwpn
, crq
->node_name
,
2571 ibmvfc_get_link_state(crq
->link_state
));
2573 switch (crq
->event
) {
2574 case IBMVFC_AE_RESUME
:
2575 switch (crq
->link_state
) {
2576 case IBMVFC_AE_LS_LINK_DOWN
:
2577 ibmvfc_link_down(vhost
, IBMVFC_LINK_DOWN
);
2579 case IBMVFC_AE_LS_LINK_DEAD
:
2580 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
2582 case IBMVFC_AE_LS_LINK_UP
:
2583 case IBMVFC_AE_LS_LINK_BOUNCED
:
2585 vhost
->events_to_log
|= IBMVFC_AE_LINKUP
;
2586 vhost
->delay_init
= 1;
2587 __ibmvfc_reset_host(vhost
);
2592 case IBMVFC_AE_LINK_UP
:
2593 vhost
->events_to_log
|= IBMVFC_AE_LINKUP
;
2594 vhost
->delay_init
= 1;
2595 __ibmvfc_reset_host(vhost
);
2597 case IBMVFC_AE_SCN_FABRIC
:
2598 case IBMVFC_AE_SCN_DOMAIN
:
2599 vhost
->events_to_log
|= IBMVFC_AE_RSCN
;
2600 vhost
->delay_init
= 1;
2601 __ibmvfc_reset_host(vhost
);
2603 case IBMVFC_AE_SCN_NPORT
:
2604 case IBMVFC_AE_SCN_GROUP
:
2605 vhost
->events_to_log
|= IBMVFC_AE_RSCN
;
2606 ibmvfc_reinit_host(vhost
);
2608 case IBMVFC_AE_ELS_LOGO
:
2609 case IBMVFC_AE_ELS_PRLO
:
2610 case IBMVFC_AE_ELS_PLOGI
:
2611 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
2612 if (!crq
->scsi_id
&& !crq
->wwpn
&& !crq
->node_name
)
2614 if (crq
->scsi_id
&& tgt
->scsi_id
!= crq
->scsi_id
)
2616 if (crq
->wwpn
&& tgt
->ids
.port_name
!= crq
->wwpn
)
2618 if (crq
->node_name
&& tgt
->ids
.node_name
!= crq
->node_name
)
2620 if (tgt
->need_login
&& crq
->event
== IBMVFC_AE_ELS_LOGO
)
2622 if (!tgt
->need_login
|| crq
->event
== IBMVFC_AE_ELS_PLOGI
) {
2623 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
2624 ibmvfc_reinit_host(vhost
);
2628 case IBMVFC_AE_LINK_DOWN
:
2629 case IBMVFC_AE_ADAPTER_FAILED
:
2630 ibmvfc_link_down(vhost
, IBMVFC_LINK_DOWN
);
2632 case IBMVFC_AE_LINK_DEAD
:
2633 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
2635 case IBMVFC_AE_HALT
:
2636 ibmvfc_link_down(vhost
, IBMVFC_HALTED
);
2639 dev_err(vhost
->dev
, "Unknown async event received: %lld\n", crq
->event
);
2645 * ibmvfc_handle_crq - Handles and frees received events in the CRQ
2646 * @crq: Command/Response queue
2647 * @vhost: ibmvfc host struct
2650 static void ibmvfc_handle_crq(struct ibmvfc_crq
*crq
, struct ibmvfc_host
*vhost
)
2653 struct ibmvfc_event
*evt
= (struct ibmvfc_event
*)crq
->ioba
;
2655 switch (crq
->valid
) {
2656 case IBMVFC_CRQ_INIT_RSP
:
2657 switch (crq
->format
) {
2658 case IBMVFC_CRQ_INIT
:
2659 dev_info(vhost
->dev
, "Partner initialized\n");
2660 /* Send back a response */
2661 rc
= ibmvfc_send_crq_init_complete(vhost
);
2663 ibmvfc_init_host(vhost
);
2665 dev_err(vhost
->dev
, "Unable to send init rsp. rc=%ld\n", rc
);
2667 case IBMVFC_CRQ_INIT_COMPLETE
:
2668 dev_info(vhost
->dev
, "Partner initialization complete\n");
2669 ibmvfc_init_host(vhost
);
2672 dev_err(vhost
->dev
, "Unknown crq message type: %d\n", crq
->format
);
2675 case IBMVFC_CRQ_XPORT_EVENT
:
2676 vhost
->state
= IBMVFC_NO_CRQ
;
2677 vhost
->logged_in
= 0;
2678 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_NONE
);
2679 if (crq
->format
== IBMVFC_PARTITION_MIGRATED
) {
2680 /* We need to re-setup the interpartition connection */
2681 dev_info(vhost
->dev
, "Re-enabling adapter\n");
2682 vhost
->client_migrated
= 1;
2683 ibmvfc_purge_requests(vhost
, DID_REQUEUE
);
2684 ibmvfc_link_down(vhost
, IBMVFC_LINK_DOWN
);
2685 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_REENABLE
);
2687 dev_err(vhost
->dev
, "Virtual adapter failed (rc=%d)\n", crq
->format
);
2688 ibmvfc_purge_requests(vhost
, DID_ERROR
);
2689 ibmvfc_link_down(vhost
, IBMVFC_LINK_DOWN
);
2690 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_RESET
);
2693 case IBMVFC_CRQ_CMD_RSP
:
2696 dev_err(vhost
->dev
, "Got an invalid message type 0x%02x\n", crq
->valid
);
2700 if (crq
->format
== IBMVFC_ASYNC_EVENT
)
2703 /* The only kind of payload CRQs we should get are responses to
2704 * things we send. Make sure this response is to something we
2707 if (unlikely(!ibmvfc_valid_event(&vhost
->pool
, evt
))) {
2708 dev_err(vhost
->dev
, "Returned correlation_token 0x%08llx is invalid!\n",
2713 if (unlikely(atomic_read(&evt
->free
))) {
2714 dev_err(vhost
->dev
, "Received duplicate correlation_token 0x%08llx!\n",
2719 del_timer(&evt
->timer
);
2720 list_del(&evt
->queue
);
2721 ibmvfc_trc_end(evt
);
2726 * ibmvfc_scan_finished - Check if the device scan is done.
2727 * @shost: scsi host struct
2728 * @time: current elapsed time
2731 * 0 if scan is not done / 1 if scan is done
2733 static int ibmvfc_scan_finished(struct Scsi_Host
*shost
, unsigned long time
)
2735 unsigned long flags
;
2736 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2739 spin_lock_irqsave(shost
->host_lock
, flags
);
2740 if (time
>= (init_timeout
* HZ
)) {
2741 dev_info(vhost
->dev
, "Scan taking longer than %d seconds, "
2742 "continuing initialization\n", init_timeout
);
2746 if (vhost
->scan_complete
)
2748 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2753 * ibmvfc_slave_alloc - Setup the device's task set value
2754 * @sdev: struct scsi_device device to configure
2756 * Set the device's task set value so that error handling works as
2760 * 0 on success / -ENXIO if device does not exist
2762 static int ibmvfc_slave_alloc(struct scsi_device
*sdev
)
2764 struct Scsi_Host
*shost
= sdev
->host
;
2765 struct fc_rport
*rport
= starget_to_rport(scsi_target(sdev
));
2766 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2767 unsigned long flags
= 0;
2769 if (!rport
|| fc_remote_port_chkready(rport
))
2772 spin_lock_irqsave(shost
->host_lock
, flags
);
2773 sdev
->hostdata
= (void *)(unsigned long)vhost
->task_set
++;
2774 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2779 * ibmvfc_target_alloc - Setup the target's task set value
2780 * @starget: struct scsi_target
2782 * Set the target's task set value so that error handling works as
2786 * 0 on success / -ENXIO if device does not exist
2788 static int ibmvfc_target_alloc(struct scsi_target
*starget
)
2790 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
2791 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2792 unsigned long flags
= 0;
2794 spin_lock_irqsave(shost
->host_lock
, flags
);
2795 starget
->hostdata
= (void *)(unsigned long)vhost
->task_set
++;
2796 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2801 * ibmvfc_slave_configure - Configure the device
2802 * @sdev: struct scsi_device device to configure
2804 * Enable allow_restart for a device if it is a disk. Adjust the
2805 * queue_depth here also.
2810 static int ibmvfc_slave_configure(struct scsi_device
*sdev
)
2812 struct Scsi_Host
*shost
= sdev
->host
;
2813 unsigned long flags
= 0;
2815 spin_lock_irqsave(shost
->host_lock
, flags
);
2816 if (sdev
->type
== TYPE_DISK
)
2817 sdev
->allow_restart
= 1;
2819 if (sdev
->tagged_supported
) {
2820 scsi_set_tag_type(sdev
, MSG_SIMPLE_TAG
);
2821 scsi_activate_tcq(sdev
, sdev
->queue_depth
);
2823 scsi_deactivate_tcq(sdev
, sdev
->queue_depth
);
2824 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2829 * ibmvfc_change_queue_depth - Change the device's queue depth
2830 * @sdev: scsi device struct
2831 * @qdepth: depth to set
2832 * @reason: calling context
2837 static int ibmvfc_change_queue_depth(struct scsi_device
*sdev
, int qdepth
,
2840 if (reason
!= SCSI_QDEPTH_DEFAULT
)
2843 if (qdepth
> IBMVFC_MAX_CMDS_PER_LUN
)
2844 qdepth
= IBMVFC_MAX_CMDS_PER_LUN
;
2846 scsi_adjust_queue_depth(sdev
, 0, qdepth
);
2847 return sdev
->queue_depth
;
2851 * ibmvfc_change_queue_type - Change the device's queue type
2852 * @sdev: scsi device struct
2853 * @tag_type: type of tags to use
2856 * actual queue type set
2858 static int ibmvfc_change_queue_type(struct scsi_device
*sdev
, int tag_type
)
2860 if (sdev
->tagged_supported
) {
2861 scsi_set_tag_type(sdev
, tag_type
);
2864 scsi_activate_tcq(sdev
, sdev
->queue_depth
);
2866 scsi_deactivate_tcq(sdev
, sdev
->queue_depth
);
2873 static ssize_t
ibmvfc_show_host_partition_name(struct device
*dev
,
2874 struct device_attribute
*attr
, char *buf
)
2876 struct Scsi_Host
*shost
= class_to_shost(dev
);
2877 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2879 return snprintf(buf
, PAGE_SIZE
, "%s\n",
2880 vhost
->login_buf
->resp
.partition_name
);
2883 static ssize_t
ibmvfc_show_host_device_name(struct device
*dev
,
2884 struct device_attribute
*attr
, char *buf
)
2886 struct Scsi_Host
*shost
= class_to_shost(dev
);
2887 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2889 return snprintf(buf
, PAGE_SIZE
, "%s\n",
2890 vhost
->login_buf
->resp
.device_name
);
2893 static ssize_t
ibmvfc_show_host_loc_code(struct device
*dev
,
2894 struct device_attribute
*attr
, char *buf
)
2896 struct Scsi_Host
*shost
= class_to_shost(dev
);
2897 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2899 return snprintf(buf
, PAGE_SIZE
, "%s\n",
2900 vhost
->login_buf
->resp
.port_loc_code
);
2903 static ssize_t
ibmvfc_show_host_drc_name(struct device
*dev
,
2904 struct device_attribute
*attr
, char *buf
)
2906 struct Scsi_Host
*shost
= class_to_shost(dev
);
2907 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2909 return snprintf(buf
, PAGE_SIZE
, "%s\n",
2910 vhost
->login_buf
->resp
.drc_name
);
2913 static ssize_t
ibmvfc_show_host_npiv_version(struct device
*dev
,
2914 struct device_attribute
*attr
, char *buf
)
2916 struct Scsi_Host
*shost
= class_to_shost(dev
);
2917 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2918 return snprintf(buf
, PAGE_SIZE
, "%d\n", vhost
->login_buf
->resp
.version
);
2921 static ssize_t
ibmvfc_show_host_capabilities(struct device
*dev
,
2922 struct device_attribute
*attr
, char *buf
)
2924 struct Scsi_Host
*shost
= class_to_shost(dev
);
2925 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2926 return snprintf(buf
, PAGE_SIZE
, "%llx\n", vhost
->login_buf
->resp
.capabilities
);
2930 * ibmvfc_show_log_level - Show the adapter's error logging level
2931 * @dev: class device struct
2935 * number of bytes printed to buffer
2937 static ssize_t
ibmvfc_show_log_level(struct device
*dev
,
2938 struct device_attribute
*attr
, char *buf
)
2940 struct Scsi_Host
*shost
= class_to_shost(dev
);
2941 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2942 unsigned long flags
= 0;
2945 spin_lock_irqsave(shost
->host_lock
, flags
);
2946 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", vhost
->log_level
);
2947 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2952 * ibmvfc_store_log_level - Change the adapter's error logging level
2953 * @dev: class device struct
2957 * number of bytes printed to buffer
2959 static ssize_t
ibmvfc_store_log_level(struct device
*dev
,
2960 struct device_attribute
*attr
,
2961 const char *buf
, size_t count
)
2963 struct Scsi_Host
*shost
= class_to_shost(dev
);
2964 struct ibmvfc_host
*vhost
= shost_priv(shost
);
2965 unsigned long flags
= 0;
2967 spin_lock_irqsave(shost
->host_lock
, flags
);
2968 vhost
->log_level
= simple_strtoul(buf
, NULL
, 10);
2969 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2973 static DEVICE_ATTR(partition_name
, S_IRUGO
, ibmvfc_show_host_partition_name
, NULL
);
2974 static DEVICE_ATTR(device_name
, S_IRUGO
, ibmvfc_show_host_device_name
, NULL
);
2975 static DEVICE_ATTR(port_loc_code
, S_IRUGO
, ibmvfc_show_host_loc_code
, NULL
);
2976 static DEVICE_ATTR(drc_name
, S_IRUGO
, ibmvfc_show_host_drc_name
, NULL
);
2977 static DEVICE_ATTR(npiv_version
, S_IRUGO
, ibmvfc_show_host_npiv_version
, NULL
);
2978 static DEVICE_ATTR(capabilities
, S_IRUGO
, ibmvfc_show_host_capabilities
, NULL
);
2979 static DEVICE_ATTR(log_level
, S_IRUGO
| S_IWUSR
,
2980 ibmvfc_show_log_level
, ibmvfc_store_log_level
);
2982 #ifdef CONFIG_SCSI_IBMVFC_TRACE
2984 * ibmvfc_read_trace - Dump the adapter trace
2985 * @filp: open sysfs file
2986 * @kobj: kobject struct
2987 * @bin_attr: bin_attribute struct
2990 * @count: buffer size
2993 * number of bytes printed to buffer
2995 static ssize_t
ibmvfc_read_trace(struct file
*filp
, struct kobject
*kobj
,
2996 struct bin_attribute
*bin_attr
,
2997 char *buf
, loff_t off
, size_t count
)
2999 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
3000 struct Scsi_Host
*shost
= class_to_shost(dev
);
3001 struct ibmvfc_host
*vhost
= shost_priv(shost
);
3002 unsigned long flags
= 0;
3003 int size
= IBMVFC_TRACE_SIZE
;
3004 char *src
= (char *)vhost
->trace
;
3008 if (off
+ count
> size
) {
3013 spin_lock_irqsave(shost
->host_lock
, flags
);
3014 memcpy(buf
, &src
[off
], count
);
3015 spin_unlock_irqrestore(shost
->host_lock
, flags
);
3019 static struct bin_attribute ibmvfc_trace_attr
= {
3025 .read
= ibmvfc_read_trace
,
3029 static struct device_attribute
*ibmvfc_attrs
[] = {
3030 &dev_attr_partition_name
,
3031 &dev_attr_device_name
,
3032 &dev_attr_port_loc_code
,
3034 &dev_attr_npiv_version
,
3035 &dev_attr_capabilities
,
3036 &dev_attr_log_level
,
3040 static struct scsi_host_template driver_template
= {
3041 .module
= THIS_MODULE
,
3042 .name
= "IBM POWER Virtual FC Adapter",
3043 .proc_name
= IBMVFC_NAME
,
3044 .queuecommand
= ibmvfc_queuecommand
,
3045 .eh_abort_handler
= ibmvfc_eh_abort_handler
,
3046 .eh_device_reset_handler
= ibmvfc_eh_device_reset_handler
,
3047 .eh_target_reset_handler
= ibmvfc_eh_target_reset_handler
,
3048 .eh_host_reset_handler
= ibmvfc_eh_host_reset_handler
,
3049 .slave_alloc
= ibmvfc_slave_alloc
,
3050 .slave_configure
= ibmvfc_slave_configure
,
3051 .target_alloc
= ibmvfc_target_alloc
,
3052 .scan_finished
= ibmvfc_scan_finished
,
3053 .change_queue_depth
= ibmvfc_change_queue_depth
,
3054 .change_queue_type
= ibmvfc_change_queue_type
,
3056 .can_queue
= IBMVFC_MAX_REQUESTS_DEFAULT
,
3058 .sg_tablesize
= SG_ALL
,
3059 .max_sectors
= IBMVFC_MAX_SECTORS
,
3060 .use_clustering
= ENABLE_CLUSTERING
,
3061 .shost_attrs
= ibmvfc_attrs
,
3065 * ibmvfc_next_async_crq - Returns the next entry in async queue
3066 * @vhost: ibmvfc host struct
3069 * Pointer to next entry in queue / NULL if empty
3071 static struct ibmvfc_async_crq
*ibmvfc_next_async_crq(struct ibmvfc_host
*vhost
)
3073 struct ibmvfc_async_crq_queue
*async_crq
= &vhost
->async_crq
;
3074 struct ibmvfc_async_crq
*crq
;
3076 crq
= &async_crq
->msgs
[async_crq
->cur
];
3077 if (crq
->valid
& 0x80) {
3078 if (++async_crq
->cur
== async_crq
->size
)
3088 * ibmvfc_next_crq - Returns the next entry in message queue
3089 * @vhost: ibmvfc host struct
3092 * Pointer to next entry in queue / NULL if empty
3094 static struct ibmvfc_crq
*ibmvfc_next_crq(struct ibmvfc_host
*vhost
)
3096 struct ibmvfc_crq_queue
*queue
= &vhost
->crq
;
3097 struct ibmvfc_crq
*crq
;
3099 crq
= &queue
->msgs
[queue
->cur
];
3100 if (crq
->valid
& 0x80) {
3101 if (++queue
->cur
== queue
->size
)
3111 * ibmvfc_interrupt - Interrupt handler
3112 * @irq: number of irq to handle, not used
3113 * @dev_instance: ibmvfc_host that received interrupt
3118 static irqreturn_t
ibmvfc_interrupt(int irq
, void *dev_instance
)
3120 struct ibmvfc_host
*vhost
= (struct ibmvfc_host
*)dev_instance
;
3121 unsigned long flags
;
3123 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
3124 vio_disable_interrupts(to_vio_dev(vhost
->dev
));
3125 tasklet_schedule(&vhost
->tasklet
);
3126 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
3131 * ibmvfc_tasklet - Interrupt handler tasklet
3132 * @data: ibmvfc host struct
3137 static void ibmvfc_tasklet(void *data
)
3139 struct ibmvfc_host
*vhost
= data
;
3140 struct vio_dev
*vdev
= to_vio_dev(vhost
->dev
);
3141 struct ibmvfc_crq
*crq
;
3142 struct ibmvfc_async_crq
*async
;
3143 unsigned long flags
;
3146 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
3148 /* Pull all the valid messages off the async CRQ */
3149 while ((async
= ibmvfc_next_async_crq(vhost
)) != NULL
) {
3150 ibmvfc_handle_async(async
, vhost
);
3155 /* Pull all the valid messages off the CRQ */
3156 while ((crq
= ibmvfc_next_crq(vhost
)) != NULL
) {
3157 ibmvfc_handle_crq(crq
, vhost
);
3162 vio_enable_interrupts(vdev
);
3163 if ((async
= ibmvfc_next_async_crq(vhost
)) != NULL
) {
3164 vio_disable_interrupts(vdev
);
3165 ibmvfc_handle_async(async
, vhost
);
3168 } else if ((crq
= ibmvfc_next_crq(vhost
)) != NULL
) {
3169 vio_disable_interrupts(vdev
);
3170 ibmvfc_handle_crq(crq
, vhost
);
3177 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
3181 * ibmvfc_init_tgt - Set the next init job step for the target
3182 * @tgt: ibmvfc target struct
3183 * @job_step: job step to perform
3186 static void ibmvfc_init_tgt(struct ibmvfc_target
*tgt
,
3187 void (*job_step
) (struct ibmvfc_target
*))
3189 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_INIT
);
3190 tgt
->job_step
= job_step
;
3191 wake_up(&tgt
->vhost
->work_wait_q
);
3195 * ibmvfc_retry_tgt_init - Attempt to retry a step in target initialization
3196 * @tgt: ibmvfc target struct
3197 * @job_step: initialization job step
3199 * Returns: 1 if step will be retried / 0 if not
3202 static int ibmvfc_retry_tgt_init(struct ibmvfc_target
*tgt
,
3203 void (*job_step
) (struct ibmvfc_target
*))
3205 if (++tgt
->init_retries
> IBMVFC_MAX_TGT_INIT_RETRIES
) {
3206 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3207 wake_up(&tgt
->vhost
->work_wait_q
);
3210 ibmvfc_init_tgt(tgt
, job_step
);
3214 /* Defined in FC-LS */
3215 static const struct {
3232 * ibmvfc_get_prli_rsp - Find PRLI response index
3233 * @flags: PRLI response flags
3236 static int ibmvfc_get_prli_rsp(u16 flags
)
3239 int code
= (flags
& 0x0f00) >> 8;
3241 for (i
= 0; i
< ARRAY_SIZE(prli_rsp
); i
++)
3242 if (prli_rsp
[i
].code
== code
)
3249 * ibmvfc_tgt_prli_done - Completion handler for Process Login
3250 * @evt: ibmvfc event struct
3253 static void ibmvfc_tgt_prli_done(struct ibmvfc_event
*evt
)
3255 struct ibmvfc_target
*tgt
= evt
->tgt
;
3256 struct ibmvfc_host
*vhost
= evt
->vhost
;
3257 struct ibmvfc_process_login
*rsp
= &evt
->xfer_iu
->prli
;
3258 struct ibmvfc_prli_svc_parms
*parms
= &rsp
->parms
;
3259 u32 status
= rsp
->common
.status
;
3260 int index
, level
= IBMVFC_DEFAULT_LOG_LEVEL
;
3262 vhost
->discovery_threads
--;
3263 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3265 case IBMVFC_MAD_SUCCESS
:
3266 tgt_dbg(tgt
, "Process Login succeeded: %X %02X %04X\n",
3267 parms
->type
, parms
->flags
, parms
->service_parms
);
3269 if (parms
->type
== IBMVFC_SCSI_FCP_TYPE
) {
3270 index
= ibmvfc_get_prli_rsp(parms
->flags
);
3271 if (prli_rsp
[index
].logged_in
) {
3272 if (parms
->flags
& IBMVFC_PRLI_EST_IMG_PAIR
) {
3273 tgt
->need_login
= 0;
3275 if (parms
->service_parms
& IBMVFC_PRLI_TARGET_FUNC
)
3276 tgt
->ids
.roles
|= FC_PORT_ROLE_FCP_TARGET
;
3277 if (parms
->service_parms
& IBMVFC_PRLI_INITIATOR_FUNC
)
3278 tgt
->ids
.roles
|= FC_PORT_ROLE_FCP_INITIATOR
;
3281 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3282 } else if (prli_rsp
[index
].retry
)
3283 ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_send_prli
);
3285 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3287 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3289 case IBMVFC_MAD_DRIVER_FAILED
:
3291 case IBMVFC_MAD_CRQ_ERROR
:
3292 ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_send_prli
);
3294 case IBMVFC_MAD_FAILED
:
3296 if ((rsp
->status
& IBMVFC_VIOS_FAILURE
) && rsp
->error
== IBMVFC_PLOGI_REQUIRED
)
3297 level
+= ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_send_plogi
);
3298 else if (tgt
->logo_rcvd
)
3299 level
+= ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_send_plogi
);
3300 else if (ibmvfc_retry_cmd(rsp
->status
, rsp
->error
))
3301 level
+= ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_send_prli
);
3303 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3305 tgt_log(tgt
, level
, "Process Login failed: %s (%x:%x) rc=0x%02X\n",
3306 ibmvfc_get_cmd_error(rsp
->status
, rsp
->error
),
3307 rsp
->status
, rsp
->error
, status
);
3311 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3312 ibmvfc_free_event(evt
);
3313 wake_up(&vhost
->work_wait_q
);
3317 * ibmvfc_tgt_send_prli - Send a process login
3318 * @tgt: ibmvfc target struct
3321 static void ibmvfc_tgt_send_prli(struct ibmvfc_target
*tgt
)
3323 struct ibmvfc_process_login
*prli
;
3324 struct ibmvfc_host
*vhost
= tgt
->vhost
;
3325 struct ibmvfc_event
*evt
;
3327 if (vhost
->discovery_threads
>= disc_threads
)
3330 kref_get(&tgt
->kref
);
3331 evt
= ibmvfc_get_event(vhost
);
3332 vhost
->discovery_threads
++;
3333 ibmvfc_init_event(evt
, ibmvfc_tgt_prli_done
, IBMVFC_MAD_FORMAT
);
3335 prli
= &evt
->iu
.prli
;
3336 memset(prli
, 0, sizeof(*prli
));
3337 prli
->common
.version
= 1;
3338 prli
->common
.opcode
= IBMVFC_PROCESS_LOGIN
;
3339 prli
->common
.length
= sizeof(*prli
);
3340 prli
->scsi_id
= tgt
->scsi_id
;
3342 prli
->parms
.type
= IBMVFC_SCSI_FCP_TYPE
;
3343 prli
->parms
.flags
= IBMVFC_PRLI_EST_IMG_PAIR
;
3344 prli
->parms
.service_parms
= IBMVFC_PRLI_INITIATOR_FUNC
;
3346 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_INIT_WAIT
);
3347 if (ibmvfc_send_event(evt
, vhost
, default_timeout
)) {
3348 vhost
->discovery_threads
--;
3349 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3350 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3352 tgt_dbg(tgt
, "Sent process login\n");
3356 * ibmvfc_tgt_plogi_done - Completion handler for Port Login
3357 * @evt: ibmvfc event struct
3360 static void ibmvfc_tgt_plogi_done(struct ibmvfc_event
*evt
)
3362 struct ibmvfc_target
*tgt
= evt
->tgt
;
3363 struct ibmvfc_host
*vhost
= evt
->vhost
;
3364 struct ibmvfc_port_login
*rsp
= &evt
->xfer_iu
->plogi
;
3365 u32 status
= rsp
->common
.status
;
3366 int level
= IBMVFC_DEFAULT_LOG_LEVEL
;
3368 vhost
->discovery_threads
--;
3369 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3371 case IBMVFC_MAD_SUCCESS
:
3372 tgt_dbg(tgt
, "Port Login succeeded\n");
3373 if (tgt
->ids
.port_name
&&
3374 tgt
->ids
.port_name
!= wwn_to_u64(rsp
->service_parms
.port_name
)) {
3376 tgt_dbg(tgt
, "Port re-init required\n");
3379 tgt
->ids
.node_name
= wwn_to_u64(rsp
->service_parms
.node_name
);
3380 tgt
->ids
.port_name
= wwn_to_u64(rsp
->service_parms
.port_name
);
3381 tgt
->ids
.port_id
= tgt
->scsi_id
;
3382 memcpy(&tgt
->service_parms
, &rsp
->service_parms
,
3383 sizeof(tgt
->service_parms
));
3384 memcpy(&tgt
->service_parms_change
, &rsp
->service_parms_change
,
3385 sizeof(tgt
->service_parms_change
));
3386 ibmvfc_init_tgt(tgt
, ibmvfc_tgt_send_prli
);
3388 case IBMVFC_MAD_DRIVER_FAILED
:
3390 case IBMVFC_MAD_CRQ_ERROR
:
3391 ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_send_plogi
);
3393 case IBMVFC_MAD_FAILED
:
3395 if (ibmvfc_retry_cmd(rsp
->status
, rsp
->error
))
3396 level
+= ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_send_plogi
);
3398 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3400 tgt_log(tgt
, level
, "Port Login failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
3401 ibmvfc_get_cmd_error(rsp
->status
, rsp
->error
), rsp
->status
, rsp
->error
,
3402 ibmvfc_get_fc_type(rsp
->fc_type
), rsp
->fc_type
,
3403 ibmvfc_get_ls_explain(rsp
->fc_explain
), rsp
->fc_explain
, status
);
3407 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3408 ibmvfc_free_event(evt
);
3409 wake_up(&vhost
->work_wait_q
);
3413 * ibmvfc_tgt_send_plogi - Send PLOGI to the specified target
3414 * @tgt: ibmvfc target struct
3417 static void ibmvfc_tgt_send_plogi(struct ibmvfc_target
*tgt
)
3419 struct ibmvfc_port_login
*plogi
;
3420 struct ibmvfc_host
*vhost
= tgt
->vhost
;
3421 struct ibmvfc_event
*evt
;
3423 if (vhost
->discovery_threads
>= disc_threads
)
3426 kref_get(&tgt
->kref
);
3428 evt
= ibmvfc_get_event(vhost
);
3429 vhost
->discovery_threads
++;
3430 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_INIT_WAIT
);
3431 ibmvfc_init_event(evt
, ibmvfc_tgt_plogi_done
, IBMVFC_MAD_FORMAT
);
3433 plogi
= &evt
->iu
.plogi
;
3434 memset(plogi
, 0, sizeof(*plogi
));
3435 plogi
->common
.version
= 1;
3436 plogi
->common
.opcode
= IBMVFC_PORT_LOGIN
;
3437 plogi
->common
.length
= sizeof(*plogi
);
3438 plogi
->scsi_id
= tgt
->scsi_id
;
3440 if (ibmvfc_send_event(evt
, vhost
, default_timeout
)) {
3441 vhost
->discovery_threads
--;
3442 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3443 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3445 tgt_dbg(tgt
, "Sent port login\n");
3449 * ibmvfc_tgt_implicit_logout_done - Completion handler for Implicit Logout MAD
3450 * @evt: ibmvfc event struct
3453 static void ibmvfc_tgt_implicit_logout_done(struct ibmvfc_event
*evt
)
3455 struct ibmvfc_target
*tgt
= evt
->tgt
;
3456 struct ibmvfc_host
*vhost
= evt
->vhost
;
3457 struct ibmvfc_implicit_logout
*rsp
= &evt
->xfer_iu
->implicit_logout
;
3458 u32 status
= rsp
->common
.status
;
3460 vhost
->discovery_threads
--;
3461 ibmvfc_free_event(evt
);
3462 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3465 case IBMVFC_MAD_SUCCESS
:
3466 tgt_dbg(tgt
, "Implicit Logout succeeded\n");
3468 case IBMVFC_MAD_DRIVER_FAILED
:
3469 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3470 wake_up(&vhost
->work_wait_q
);
3472 case IBMVFC_MAD_FAILED
:
3474 tgt_err(tgt
, "Implicit Logout failed: rc=0x%02X\n", status
);
3478 if (vhost
->action
== IBMVFC_HOST_ACTION_TGT_INIT
)
3479 ibmvfc_init_tgt(tgt
, ibmvfc_tgt_send_plogi
);
3480 else if (vhost
->action
== IBMVFC_HOST_ACTION_QUERY_TGTS
&&
3481 tgt
->scsi_id
!= tgt
->new_scsi_id
)
3482 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3483 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3484 wake_up(&vhost
->work_wait_q
);
3488 * ibmvfc_tgt_implicit_logout - Initiate an Implicit Logout for specified target
3489 * @tgt: ibmvfc target struct
3492 static void ibmvfc_tgt_implicit_logout(struct ibmvfc_target
*tgt
)
3494 struct ibmvfc_implicit_logout
*mad
;
3495 struct ibmvfc_host
*vhost
= tgt
->vhost
;
3496 struct ibmvfc_event
*evt
;
3498 if (vhost
->discovery_threads
>= disc_threads
)
3501 kref_get(&tgt
->kref
);
3502 evt
= ibmvfc_get_event(vhost
);
3503 vhost
->discovery_threads
++;
3504 ibmvfc_init_event(evt
, ibmvfc_tgt_implicit_logout_done
, IBMVFC_MAD_FORMAT
);
3506 mad
= &evt
->iu
.implicit_logout
;
3507 memset(mad
, 0, sizeof(*mad
));
3508 mad
->common
.version
= 1;
3509 mad
->common
.opcode
= IBMVFC_IMPLICIT_LOGOUT
;
3510 mad
->common
.length
= sizeof(*mad
);
3511 mad
->old_scsi_id
= tgt
->scsi_id
;
3513 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_INIT_WAIT
);
3514 if (ibmvfc_send_event(evt
, vhost
, default_timeout
)) {
3515 vhost
->discovery_threads
--;
3516 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3517 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3519 tgt_dbg(tgt
, "Sent Implicit Logout\n");
3523 * ibmvfc_adisc_needs_plogi - Does device need PLOGI?
3524 * @mad: ibmvfc passthru mad struct
3525 * @tgt: ibmvfc target struct
3528 * 1 if PLOGI needed / 0 if PLOGI not needed
3530 static int ibmvfc_adisc_needs_plogi(struct ibmvfc_passthru_mad
*mad
,
3531 struct ibmvfc_target
*tgt
)
3533 if (memcmp(&mad
->fc_iu
.response
[2], &tgt
->ids
.port_name
,
3534 sizeof(tgt
->ids
.port_name
)))
3536 if (memcmp(&mad
->fc_iu
.response
[4], &tgt
->ids
.node_name
,
3537 sizeof(tgt
->ids
.node_name
)))
3539 if (mad
->fc_iu
.response
[6] != tgt
->scsi_id
)
3545 * ibmvfc_tgt_adisc_done - Completion handler for ADISC
3546 * @evt: ibmvfc event struct
3549 static void ibmvfc_tgt_adisc_done(struct ibmvfc_event
*evt
)
3551 struct ibmvfc_target
*tgt
= evt
->tgt
;
3552 struct ibmvfc_host
*vhost
= evt
->vhost
;
3553 struct ibmvfc_passthru_mad
*mad
= &evt
->xfer_iu
->passthru
;
3554 u32 status
= mad
->common
.status
;
3555 u8 fc_reason
, fc_explain
;
3557 vhost
->discovery_threads
--;
3558 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3559 del_timer(&tgt
->timer
);
3562 case IBMVFC_MAD_SUCCESS
:
3563 tgt_dbg(tgt
, "ADISC succeeded\n");
3564 if (ibmvfc_adisc_needs_plogi(mad
, tgt
))
3565 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3567 case IBMVFC_MAD_DRIVER_FAILED
:
3569 case IBMVFC_MAD_FAILED
:
3571 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3572 fc_reason
= (mad
->fc_iu
.response
[1] & 0x00ff0000) >> 16;
3573 fc_explain
= (mad
->fc_iu
.response
[1] & 0x0000ff00) >> 8;
3574 tgt_info(tgt
, "ADISC failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
3575 ibmvfc_get_cmd_error(mad
->iu
.status
, mad
->iu
.error
),
3576 mad
->iu
.status
, mad
->iu
.error
,
3577 ibmvfc_get_fc_type(fc_reason
), fc_reason
,
3578 ibmvfc_get_ls_explain(fc_explain
), fc_explain
, status
);
3582 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3583 ibmvfc_free_event(evt
);
3584 wake_up(&vhost
->work_wait_q
);
3588 * ibmvfc_init_passthru - Initialize an event struct for FC passthru
3589 * @evt: ibmvfc event struct
3592 static void ibmvfc_init_passthru(struct ibmvfc_event
*evt
)
3594 struct ibmvfc_passthru_mad
*mad
= &evt
->iu
.passthru
;
3596 memset(mad
, 0, sizeof(*mad
));
3597 mad
->common
.version
= 1;
3598 mad
->common
.opcode
= IBMVFC_PASSTHRU
;
3599 mad
->common
.length
= sizeof(*mad
) - sizeof(mad
->fc_iu
) - sizeof(mad
->iu
);
3600 mad
->cmd_ioba
.va
= (u64
)evt
->crq
.ioba
+
3601 offsetof(struct ibmvfc_passthru_mad
, iu
);
3602 mad
->cmd_ioba
.len
= sizeof(mad
->iu
);
3603 mad
->iu
.cmd_len
= sizeof(mad
->fc_iu
.payload
);
3604 mad
->iu
.rsp_len
= sizeof(mad
->fc_iu
.response
);
3605 mad
->iu
.cmd
.va
= (u64
)evt
->crq
.ioba
+
3606 offsetof(struct ibmvfc_passthru_mad
, fc_iu
) +
3607 offsetof(struct ibmvfc_passthru_fc_iu
, payload
);
3608 mad
->iu
.cmd
.len
= sizeof(mad
->fc_iu
.payload
);
3609 mad
->iu
.rsp
.va
= (u64
)evt
->crq
.ioba
+
3610 offsetof(struct ibmvfc_passthru_mad
, fc_iu
) +
3611 offsetof(struct ibmvfc_passthru_fc_iu
, response
);
3612 mad
->iu
.rsp
.len
= sizeof(mad
->fc_iu
.response
);
3616 * ibmvfc_tgt_adisc_cancel_done - Completion handler when cancelling an ADISC
3617 * @evt: ibmvfc event struct
3619 * Just cleanup this event struct. Everything else is handled by
3620 * the ADISC completion handler. If the ADISC never actually comes
3621 * back, we still have the timer running on the ADISC event struct
3622 * which will fire and cause the CRQ to get reset.
3625 static void ibmvfc_tgt_adisc_cancel_done(struct ibmvfc_event
*evt
)
3627 struct ibmvfc_host
*vhost
= evt
->vhost
;
3628 struct ibmvfc_target
*tgt
= evt
->tgt
;
3630 tgt_dbg(tgt
, "ADISC cancel complete\n");
3631 vhost
->abort_threads
--;
3632 ibmvfc_free_event(evt
);
3633 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3634 wake_up(&vhost
->work_wait_q
);
3638 * ibmvfc_adisc_timeout - Handle an ADISC timeout
3639 * @tgt: ibmvfc target struct
3641 * If an ADISC times out, send a cancel. If the cancel times
3642 * out, reset the CRQ. When the ADISC comes back as cancelled,
3643 * log back into the target.
3645 static void ibmvfc_adisc_timeout(struct ibmvfc_target
*tgt
)
3647 struct ibmvfc_host
*vhost
= tgt
->vhost
;
3648 struct ibmvfc_event
*evt
;
3649 struct ibmvfc_tmf
*tmf
;
3650 unsigned long flags
;
3653 tgt_dbg(tgt
, "ADISC timeout\n");
3654 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
3655 if (vhost
->abort_threads
>= disc_threads
||
3656 tgt
->action
!= IBMVFC_TGT_ACTION_INIT_WAIT
||
3657 vhost
->state
!= IBMVFC_INITIALIZING
||
3658 vhost
->action
!= IBMVFC_HOST_ACTION_QUERY_TGTS
) {
3659 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
3663 vhost
->abort_threads
++;
3664 kref_get(&tgt
->kref
);
3665 evt
= ibmvfc_get_event(vhost
);
3666 ibmvfc_init_event(evt
, ibmvfc_tgt_adisc_cancel_done
, IBMVFC_MAD_FORMAT
);
3670 memset(tmf
, 0, sizeof(*tmf
));
3671 tmf
->common
.version
= 1;
3672 tmf
->common
.opcode
= IBMVFC_TMF_MAD
;
3673 tmf
->common
.length
= sizeof(*tmf
);
3674 tmf
->scsi_id
= tgt
->scsi_id
;
3675 tmf
->cancel_key
= tgt
->cancel_key
;
3677 rc
= ibmvfc_send_event(evt
, vhost
, default_timeout
);
3680 tgt_err(tgt
, "Failed to send cancel event for ADISC. rc=%d\n", rc
);
3681 vhost
->abort_threads
--;
3682 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3683 __ibmvfc_reset_host(vhost
);
3685 tgt_dbg(tgt
, "Attempting to cancel ADISC\n");
3686 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
3690 * ibmvfc_tgt_adisc - Initiate an ADISC for specified target
3691 * @tgt: ibmvfc target struct
3693 * When sending an ADISC we end up with two timers running. The
3694 * first timer is the timer in the ibmvfc target struct. If this
3695 * fires, we send a cancel to the target. The second timer is the
3696 * timer on the ibmvfc event for the ADISC, which is longer. If that
3697 * fires, it means the ADISC timed out and our attempt to cancel it
3698 * also failed, so we need to reset the CRQ.
3700 static void ibmvfc_tgt_adisc(struct ibmvfc_target
*tgt
)
3702 struct ibmvfc_passthru_mad
*mad
;
3703 struct ibmvfc_host
*vhost
= tgt
->vhost
;
3704 struct ibmvfc_event
*evt
;
3706 if (vhost
->discovery_threads
>= disc_threads
)
3709 kref_get(&tgt
->kref
);
3710 evt
= ibmvfc_get_event(vhost
);
3711 vhost
->discovery_threads
++;
3712 ibmvfc_init_event(evt
, ibmvfc_tgt_adisc_done
, IBMVFC_MAD_FORMAT
);
3715 ibmvfc_init_passthru(evt
);
3716 mad
= &evt
->iu
.passthru
;
3717 mad
->iu
.flags
= IBMVFC_FC_ELS
;
3718 mad
->iu
.scsi_id
= tgt
->scsi_id
;
3719 mad
->iu
.cancel_key
= tgt
->cancel_key
;
3721 mad
->fc_iu
.payload
[0] = IBMVFC_ADISC
;
3722 memcpy(&mad
->fc_iu
.payload
[2], &vhost
->login_buf
->resp
.port_name
,
3723 sizeof(vhost
->login_buf
->resp
.port_name
));
3724 memcpy(&mad
->fc_iu
.payload
[4], &vhost
->login_buf
->resp
.node_name
,
3725 sizeof(vhost
->login_buf
->resp
.node_name
));
3726 mad
->fc_iu
.payload
[6] = vhost
->login_buf
->resp
.scsi_id
& 0x00ffffff;
3728 if (timer_pending(&tgt
->timer
))
3729 mod_timer(&tgt
->timer
, jiffies
+ (IBMVFC_ADISC_TIMEOUT
* HZ
));
3731 tgt
->timer
.data
= (unsigned long) tgt
;
3732 tgt
->timer
.expires
= jiffies
+ (IBMVFC_ADISC_TIMEOUT
* HZ
);
3733 tgt
->timer
.function
= (void (*)(unsigned long))ibmvfc_adisc_timeout
;
3734 add_timer(&tgt
->timer
);
3737 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_INIT_WAIT
);
3738 if (ibmvfc_send_event(evt
, vhost
, IBMVFC_ADISC_PLUS_CANCEL_TIMEOUT
)) {
3739 vhost
->discovery_threads
--;
3740 del_timer(&tgt
->timer
);
3741 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3742 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3744 tgt_dbg(tgt
, "Sent ADISC\n");
3748 * ibmvfc_tgt_query_target_done - Completion handler for Query Target MAD
3749 * @evt: ibmvfc event struct
3752 static void ibmvfc_tgt_query_target_done(struct ibmvfc_event
*evt
)
3754 struct ibmvfc_target
*tgt
= evt
->tgt
;
3755 struct ibmvfc_host
*vhost
= evt
->vhost
;
3756 struct ibmvfc_query_tgt
*rsp
= &evt
->xfer_iu
->query_tgt
;
3757 u32 status
= rsp
->common
.status
;
3758 int level
= IBMVFC_DEFAULT_LOG_LEVEL
;
3760 vhost
->discovery_threads
--;
3761 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3763 case IBMVFC_MAD_SUCCESS
:
3764 tgt_dbg(tgt
, "Query Target succeeded\n");
3765 tgt
->new_scsi_id
= rsp
->scsi_id
;
3766 if (rsp
->scsi_id
!= tgt
->scsi_id
)
3767 ibmvfc_init_tgt(tgt
, ibmvfc_tgt_implicit_logout
);
3769 ibmvfc_init_tgt(tgt
, ibmvfc_tgt_adisc
);
3771 case IBMVFC_MAD_DRIVER_FAILED
:
3773 case IBMVFC_MAD_CRQ_ERROR
:
3774 ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_query_target
);
3776 case IBMVFC_MAD_FAILED
:
3778 if ((rsp
->status
& IBMVFC_FABRIC_MAPPED
) == IBMVFC_FABRIC_MAPPED
&&
3779 rsp
->error
== IBMVFC_UNABLE_TO_PERFORM_REQ
&&
3780 rsp
->fc_explain
== IBMVFC_PORT_NAME_NOT_REG
)
3781 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3782 else if (ibmvfc_retry_cmd(rsp
->status
, rsp
->error
))
3783 level
+= ibmvfc_retry_tgt_init(tgt
, ibmvfc_tgt_query_target
);
3785 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DEL_RPORT
);
3787 tgt_log(tgt
, level
, "Query Target failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
3788 ibmvfc_get_cmd_error(rsp
->status
, rsp
->error
), rsp
->status
, rsp
->error
,
3789 ibmvfc_get_fc_type(rsp
->fc_type
), rsp
->fc_type
,
3790 ibmvfc_get_gs_explain(rsp
->fc_explain
), rsp
->fc_explain
, status
);
3794 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3795 ibmvfc_free_event(evt
);
3796 wake_up(&vhost
->work_wait_q
);
3800 * ibmvfc_tgt_query_target - Initiate a Query Target for specified target
3801 * @tgt: ibmvfc target struct
3804 static void ibmvfc_tgt_query_target(struct ibmvfc_target
*tgt
)
3806 struct ibmvfc_query_tgt
*query_tgt
;
3807 struct ibmvfc_host
*vhost
= tgt
->vhost
;
3808 struct ibmvfc_event
*evt
;
3810 if (vhost
->discovery_threads
>= disc_threads
)
3813 kref_get(&tgt
->kref
);
3814 evt
= ibmvfc_get_event(vhost
);
3815 vhost
->discovery_threads
++;
3817 ibmvfc_init_event(evt
, ibmvfc_tgt_query_target_done
, IBMVFC_MAD_FORMAT
);
3818 query_tgt
= &evt
->iu
.query_tgt
;
3819 memset(query_tgt
, 0, sizeof(*query_tgt
));
3820 query_tgt
->common
.version
= 1;
3821 query_tgt
->common
.opcode
= IBMVFC_QUERY_TARGET
;
3822 query_tgt
->common
.length
= sizeof(*query_tgt
);
3823 query_tgt
->wwpn
= tgt
->ids
.port_name
;
3825 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_INIT_WAIT
);
3826 if (ibmvfc_send_event(evt
, vhost
, default_timeout
)) {
3827 vhost
->discovery_threads
--;
3828 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_NONE
);
3829 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
3831 tgt_dbg(tgt
, "Sent Query Target\n");
3835 * ibmvfc_alloc_target - Allocate and initialize an ibmvfc target
3836 * @vhost: ibmvfc host struct
3837 * @scsi_id: SCSI ID to allocate target for
3840 * 0 on success / other on failure
3842 static int ibmvfc_alloc_target(struct ibmvfc_host
*vhost
, u64 scsi_id
)
3844 struct ibmvfc_target
*tgt
;
3845 unsigned long flags
;
3847 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
3848 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
3849 if (tgt
->scsi_id
== scsi_id
) {
3850 if (tgt
->need_login
)
3851 ibmvfc_init_tgt(tgt
, ibmvfc_tgt_implicit_logout
);
3855 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
3857 tgt
= mempool_alloc(vhost
->tgt_pool
, GFP_NOIO
);
3859 dev_err(vhost
->dev
, "Target allocation failure for scsi id %08llx\n",
3864 memset(tgt
, 0, sizeof(*tgt
));
3865 tgt
->scsi_id
= scsi_id
;
3866 tgt
->new_scsi_id
= scsi_id
;
3868 tgt
->need_login
= 1;
3869 tgt
->cancel_key
= vhost
->task_set
++;
3870 init_timer(&tgt
->timer
);
3871 kref_init(&tgt
->kref
);
3872 ibmvfc_init_tgt(tgt
, ibmvfc_tgt_implicit_logout
);
3873 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
3874 list_add_tail(&tgt
->queue
, &vhost
->targets
);
3877 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
3882 * ibmvfc_alloc_targets - Allocate and initialize ibmvfc targets
3883 * @vhost: ibmvfc host struct
3886 * 0 on success / other on failure
3888 static int ibmvfc_alloc_targets(struct ibmvfc_host
*vhost
)
3892 for (i
= 0, rc
= 0; !rc
&& i
< vhost
->num_targets
; i
++)
3893 rc
= ibmvfc_alloc_target(vhost
,
3894 vhost
->disc_buf
->scsi_id
[i
] & IBMVFC_DISC_TGT_SCSI_ID_MASK
);
3900 * ibmvfc_discover_targets_done - Completion handler for discover targets MAD
3901 * @evt: ibmvfc event struct
3904 static void ibmvfc_discover_targets_done(struct ibmvfc_event
*evt
)
3906 struct ibmvfc_host
*vhost
= evt
->vhost
;
3907 struct ibmvfc_discover_targets
*rsp
= &evt
->xfer_iu
->discover_targets
;
3908 u32 mad_status
= rsp
->common
.status
;
3909 int level
= IBMVFC_DEFAULT_LOG_LEVEL
;
3911 switch (mad_status
) {
3912 case IBMVFC_MAD_SUCCESS
:
3913 ibmvfc_dbg(vhost
, "Discover Targets succeeded\n");
3914 vhost
->num_targets
= rsp
->num_written
;
3915 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_ALLOC_TGTS
);
3917 case IBMVFC_MAD_FAILED
:
3918 level
+= ibmvfc_retry_host_init(vhost
);
3919 ibmvfc_log(vhost
, level
, "Discover Targets failed: %s (%x:%x)\n",
3920 ibmvfc_get_cmd_error(rsp
->status
, rsp
->error
), rsp
->status
, rsp
->error
);
3922 case IBMVFC_MAD_DRIVER_FAILED
:
3925 dev_err(vhost
->dev
, "Invalid Discover Targets response: 0x%x\n", mad_status
);
3926 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
3930 ibmvfc_free_event(evt
);
3931 wake_up(&vhost
->work_wait_q
);
3935 * ibmvfc_discover_targets - Send Discover Targets MAD
3936 * @vhost: ibmvfc host struct
3939 static void ibmvfc_discover_targets(struct ibmvfc_host
*vhost
)
3941 struct ibmvfc_discover_targets
*mad
;
3942 struct ibmvfc_event
*evt
= ibmvfc_get_event(vhost
);
3944 ibmvfc_init_event(evt
, ibmvfc_discover_targets_done
, IBMVFC_MAD_FORMAT
);
3945 mad
= &evt
->iu
.discover_targets
;
3946 memset(mad
, 0, sizeof(*mad
));
3947 mad
->common
.version
= 1;
3948 mad
->common
.opcode
= IBMVFC_DISC_TARGETS
;
3949 mad
->common
.length
= sizeof(*mad
);
3950 mad
->bufflen
= vhost
->disc_buf_sz
;
3951 mad
->buffer
.va
= vhost
->disc_buf_dma
;
3952 mad
->buffer
.len
= vhost
->disc_buf_sz
;
3953 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_INIT_WAIT
);
3955 if (!ibmvfc_send_event(evt
, vhost
, default_timeout
))
3956 ibmvfc_dbg(vhost
, "Sent discover targets\n");
3958 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
3962 * ibmvfc_npiv_login_done - Completion handler for NPIV Login
3963 * @evt: ibmvfc event struct
3966 static void ibmvfc_npiv_login_done(struct ibmvfc_event
*evt
)
3968 struct ibmvfc_host
*vhost
= evt
->vhost
;
3969 u32 mad_status
= evt
->xfer_iu
->npiv_login
.common
.status
;
3970 struct ibmvfc_npiv_login_resp
*rsp
= &vhost
->login_buf
->resp
;
3971 unsigned int npiv_max_sectors
;
3972 int level
= IBMVFC_DEFAULT_LOG_LEVEL
;
3974 switch (mad_status
) {
3975 case IBMVFC_MAD_SUCCESS
:
3976 ibmvfc_free_event(evt
);
3978 case IBMVFC_MAD_FAILED
:
3979 if (ibmvfc_retry_cmd(rsp
->status
, rsp
->error
))
3980 level
+= ibmvfc_retry_host_init(vhost
);
3982 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
3983 ibmvfc_log(vhost
, level
, "NPIV Login failed: %s (%x:%x)\n",
3984 ibmvfc_get_cmd_error(rsp
->status
, rsp
->error
), rsp
->status
, rsp
->error
);
3985 ibmvfc_free_event(evt
);
3987 case IBMVFC_MAD_CRQ_ERROR
:
3988 ibmvfc_retry_host_init(vhost
);
3989 case IBMVFC_MAD_DRIVER_FAILED
:
3990 ibmvfc_free_event(evt
);
3993 dev_err(vhost
->dev
, "Invalid NPIV Login response: 0x%x\n", mad_status
);
3994 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
3995 ibmvfc_free_event(evt
);
3999 vhost
->client_migrated
= 0;
4001 if (!(rsp
->flags
& IBMVFC_NATIVE_FC
)) {
4002 dev_err(vhost
->dev
, "Virtual adapter does not support FC. %x\n",
4004 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
4005 wake_up(&vhost
->work_wait_q
);
4009 if (rsp
->max_cmds
<= IBMVFC_NUM_INTERNAL_REQ
) {
4010 dev_err(vhost
->dev
, "Virtual adapter supported queue depth too small: %d\n",
4012 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
4013 wake_up(&vhost
->work_wait_q
);
4017 vhost
->logged_in
= 1;
4018 npiv_max_sectors
= min((uint
)(rsp
->max_dma_len
>> 9), IBMVFC_MAX_SECTORS
);
4019 dev_info(vhost
->dev
, "Host partition: %s, device: %s %s %s max sectors %u\n",
4020 rsp
->partition_name
, rsp
->device_name
, rsp
->port_loc_code
,
4021 rsp
->drc_name
, npiv_max_sectors
);
4023 fc_host_fabric_name(vhost
->host
) = rsp
->node_name
;
4024 fc_host_node_name(vhost
->host
) = rsp
->node_name
;
4025 fc_host_port_name(vhost
->host
) = rsp
->port_name
;
4026 fc_host_port_id(vhost
->host
) = rsp
->scsi_id
;
4027 fc_host_port_type(vhost
->host
) = FC_PORTTYPE_NPIV
;
4028 fc_host_supported_classes(vhost
->host
) = 0;
4029 if (rsp
->service_parms
.class1_parms
[0] & 0x80000000)
4030 fc_host_supported_classes(vhost
->host
) |= FC_COS_CLASS1
;
4031 if (rsp
->service_parms
.class2_parms
[0] & 0x80000000)
4032 fc_host_supported_classes(vhost
->host
) |= FC_COS_CLASS2
;
4033 if (rsp
->service_parms
.class3_parms
[0] & 0x80000000)
4034 fc_host_supported_classes(vhost
->host
) |= FC_COS_CLASS3
;
4035 fc_host_maxframe_size(vhost
->host
) =
4036 rsp
->service_parms
.common
.bb_rcv_sz
& 0x0fff;
4038 vhost
->host
->can_queue
= rsp
->max_cmds
- IBMVFC_NUM_INTERNAL_REQ
;
4039 vhost
->host
->max_sectors
= npiv_max_sectors
;
4040 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_QUERY
);
4041 wake_up(&vhost
->work_wait_q
);
4045 * ibmvfc_npiv_login - Sends NPIV login
4046 * @vhost: ibmvfc host struct
4049 static void ibmvfc_npiv_login(struct ibmvfc_host
*vhost
)
4051 struct ibmvfc_npiv_login_mad
*mad
;
4052 struct ibmvfc_event
*evt
= ibmvfc_get_event(vhost
);
4054 ibmvfc_gather_partition_info(vhost
);
4055 ibmvfc_set_login_info(vhost
);
4056 ibmvfc_init_event(evt
, ibmvfc_npiv_login_done
, IBMVFC_MAD_FORMAT
);
4058 memcpy(vhost
->login_buf
, &vhost
->login_info
, sizeof(vhost
->login_info
));
4059 mad
= &evt
->iu
.npiv_login
;
4060 memset(mad
, 0, sizeof(struct ibmvfc_npiv_login_mad
));
4061 mad
->common
.version
= 1;
4062 mad
->common
.opcode
= IBMVFC_NPIV_LOGIN
;
4063 mad
->common
.length
= sizeof(struct ibmvfc_npiv_login_mad
);
4064 mad
->buffer
.va
= vhost
->login_buf_dma
;
4065 mad
->buffer
.len
= sizeof(*vhost
->login_buf
);
4067 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_INIT_WAIT
);
4069 if (!ibmvfc_send_event(evt
, vhost
, default_timeout
))
4070 ibmvfc_dbg(vhost
, "Sent NPIV login\n");
4072 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
4076 * ibmvfc_npiv_logout_done - Completion handler for NPIV Logout
4077 * @vhost: ibmvfc host struct
4080 static void ibmvfc_npiv_logout_done(struct ibmvfc_event
*evt
)
4082 struct ibmvfc_host
*vhost
= evt
->vhost
;
4083 u32 mad_status
= evt
->xfer_iu
->npiv_logout
.common
.status
;
4085 ibmvfc_free_event(evt
);
4087 switch (mad_status
) {
4088 case IBMVFC_MAD_SUCCESS
:
4089 if (list_empty(&vhost
->sent
) &&
4090 vhost
->action
== IBMVFC_HOST_ACTION_LOGO_WAIT
) {
4091 ibmvfc_init_host(vhost
);
4095 case IBMVFC_MAD_FAILED
:
4096 case IBMVFC_MAD_NOT_SUPPORTED
:
4097 case IBMVFC_MAD_CRQ_ERROR
:
4098 case IBMVFC_MAD_DRIVER_FAILED
:
4100 ibmvfc_dbg(vhost
, "NPIV Logout failed. 0x%X\n", mad_status
);
4104 ibmvfc_hard_reset_host(vhost
);
4108 * ibmvfc_npiv_logout - Issue an NPIV Logout
4109 * @vhost: ibmvfc host struct
4112 static void ibmvfc_npiv_logout(struct ibmvfc_host
*vhost
)
4114 struct ibmvfc_npiv_logout_mad
*mad
;
4115 struct ibmvfc_event
*evt
;
4117 evt
= ibmvfc_get_event(vhost
);
4118 ibmvfc_init_event(evt
, ibmvfc_npiv_logout_done
, IBMVFC_MAD_FORMAT
);
4120 mad
= &evt
->iu
.npiv_logout
;
4121 memset(mad
, 0, sizeof(*mad
));
4122 mad
->common
.version
= 1;
4123 mad
->common
.opcode
= IBMVFC_NPIV_LOGOUT
;
4124 mad
->common
.length
= sizeof(struct ibmvfc_npiv_logout_mad
);
4126 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_LOGO_WAIT
);
4128 if (!ibmvfc_send_event(evt
, vhost
, default_timeout
))
4129 ibmvfc_dbg(vhost
, "Sent NPIV logout\n");
4131 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
4135 * ibmvfc_dev_init_to_do - Is there target initialization work to do?
4136 * @vhost: ibmvfc host struct
4139 * 1 if work to do / 0 if not
4141 static int ibmvfc_dev_init_to_do(struct ibmvfc_host
*vhost
)
4143 struct ibmvfc_target
*tgt
;
4145 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
4146 if (tgt
->action
== IBMVFC_TGT_ACTION_INIT
||
4147 tgt
->action
== IBMVFC_TGT_ACTION_INIT_WAIT
)
4155 * __ibmvfc_work_to_do - Is there task level work to do? (no locking)
4156 * @vhost: ibmvfc host struct
4159 * 1 if work to do / 0 if not
4161 static int __ibmvfc_work_to_do(struct ibmvfc_host
*vhost
)
4163 struct ibmvfc_target
*tgt
;
4165 if (kthread_should_stop())
4167 switch (vhost
->action
) {
4168 case IBMVFC_HOST_ACTION_NONE
:
4169 case IBMVFC_HOST_ACTION_INIT_WAIT
:
4170 case IBMVFC_HOST_ACTION_LOGO_WAIT
:
4172 case IBMVFC_HOST_ACTION_TGT_INIT
:
4173 case IBMVFC_HOST_ACTION_QUERY_TGTS
:
4174 if (vhost
->discovery_threads
== disc_threads
)
4176 list_for_each_entry(tgt
, &vhost
->targets
, queue
)
4177 if (tgt
->action
== IBMVFC_TGT_ACTION_INIT
)
4179 list_for_each_entry(tgt
, &vhost
->targets
, queue
)
4180 if (tgt
->action
== IBMVFC_TGT_ACTION_INIT_WAIT
)
4183 case IBMVFC_HOST_ACTION_LOGO
:
4184 case IBMVFC_HOST_ACTION_INIT
:
4185 case IBMVFC_HOST_ACTION_ALLOC_TGTS
:
4186 case IBMVFC_HOST_ACTION_TGT_DEL
:
4187 case IBMVFC_HOST_ACTION_TGT_DEL_FAILED
:
4188 case IBMVFC_HOST_ACTION_QUERY
:
4189 case IBMVFC_HOST_ACTION_RESET
:
4190 case IBMVFC_HOST_ACTION_REENABLE
:
4199 * ibmvfc_work_to_do - Is there task level work to do?
4200 * @vhost: ibmvfc host struct
4203 * 1 if work to do / 0 if not
4205 static int ibmvfc_work_to_do(struct ibmvfc_host
*vhost
)
4207 unsigned long flags
;
4210 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4211 rc
= __ibmvfc_work_to_do(vhost
);
4212 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4217 * ibmvfc_log_ae - Log async events if necessary
4218 * @vhost: ibmvfc host struct
4219 * @events: events to log
4222 static void ibmvfc_log_ae(struct ibmvfc_host
*vhost
, int events
)
4224 if (events
& IBMVFC_AE_RSCN
)
4225 fc_host_post_event(vhost
->host
, fc_get_event_number(), FCH_EVT_RSCN
, 0);
4226 if ((events
& IBMVFC_AE_LINKDOWN
) &&
4227 vhost
->state
>= IBMVFC_HALTED
)
4228 fc_host_post_event(vhost
->host
, fc_get_event_number(), FCH_EVT_LINKDOWN
, 0);
4229 if ((events
& IBMVFC_AE_LINKUP
) &&
4230 vhost
->state
== IBMVFC_INITIALIZING
)
4231 fc_host_post_event(vhost
->host
, fc_get_event_number(), FCH_EVT_LINKUP
, 0);
4235 * ibmvfc_tgt_add_rport - Tell the FC transport about a new remote port
4236 * @tgt: ibmvfc target struct
4239 static void ibmvfc_tgt_add_rport(struct ibmvfc_target
*tgt
)
4241 struct ibmvfc_host
*vhost
= tgt
->vhost
;
4242 struct fc_rport
*rport
;
4243 unsigned long flags
;
4245 tgt_dbg(tgt
, "Adding rport\n");
4246 rport
= fc_remote_port_add(vhost
->host
, 0, &tgt
->ids
);
4247 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4249 if (rport
&& tgt
->action
== IBMVFC_TGT_ACTION_DEL_RPORT
) {
4250 tgt_dbg(tgt
, "Deleting rport\n");
4251 list_del(&tgt
->queue
);
4252 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DELETED_RPORT
);
4253 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4254 fc_remote_port_delete(rport
);
4255 del_timer_sync(&tgt
->timer
);
4256 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
4258 } else if (rport
&& tgt
->action
== IBMVFC_TGT_ACTION_DELETED_RPORT
) {
4259 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4264 tgt_dbg(tgt
, "rport add succeeded\n");
4266 rport
->maxframe_size
= tgt
->service_parms
.common
.bb_rcv_sz
& 0x0fff;
4267 rport
->supported_classes
= 0;
4268 tgt
->target_id
= rport
->scsi_target_id
;
4269 if (tgt
->service_parms
.class1_parms
[0] & 0x80000000)
4270 rport
->supported_classes
|= FC_COS_CLASS1
;
4271 if (tgt
->service_parms
.class2_parms
[0] & 0x80000000)
4272 rport
->supported_classes
|= FC_COS_CLASS2
;
4273 if (tgt
->service_parms
.class3_parms
[0] & 0x80000000)
4274 rport
->supported_classes
|= FC_COS_CLASS3
;
4276 blk_queue_max_segments(rport
->rqst_q
, 1);
4278 tgt_dbg(tgt
, "rport add failed\n");
4279 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4283 * ibmvfc_do_work - Do task level work
4284 * @vhost: ibmvfc host struct
4287 static void ibmvfc_do_work(struct ibmvfc_host
*vhost
)
4289 struct ibmvfc_target
*tgt
;
4290 unsigned long flags
;
4291 struct fc_rport
*rport
;
4294 ibmvfc_log_ae(vhost
, vhost
->events_to_log
);
4295 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4296 vhost
->events_to_log
= 0;
4297 switch (vhost
->action
) {
4298 case IBMVFC_HOST_ACTION_NONE
:
4299 case IBMVFC_HOST_ACTION_LOGO_WAIT
:
4300 case IBMVFC_HOST_ACTION_INIT_WAIT
:
4302 case IBMVFC_HOST_ACTION_RESET
:
4303 vhost
->action
= IBMVFC_HOST_ACTION_TGT_DEL
;
4304 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4305 rc
= ibmvfc_reset_crq(vhost
);
4306 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4308 vio_enable_interrupts(to_vio_dev(vhost
->dev
));
4309 else if (rc
|| (rc
= ibmvfc_send_crq_init(vhost
)) ||
4310 (rc
= vio_enable_interrupts(to_vio_dev(vhost
->dev
)))) {
4311 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
4312 dev_err(vhost
->dev
, "Error after reset (rc=%d)\n", rc
);
4315 case IBMVFC_HOST_ACTION_REENABLE
:
4316 vhost
->action
= IBMVFC_HOST_ACTION_TGT_DEL
;
4317 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4318 rc
= ibmvfc_reenable_crq_queue(vhost
);
4319 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4320 if (rc
|| (rc
= ibmvfc_send_crq_init(vhost
))) {
4321 ibmvfc_link_down(vhost
, IBMVFC_LINK_DEAD
);
4322 dev_err(vhost
->dev
, "Error after enable (rc=%d)\n", rc
);
4325 case IBMVFC_HOST_ACTION_LOGO
:
4326 vhost
->job_step(vhost
);
4328 case IBMVFC_HOST_ACTION_INIT
:
4329 BUG_ON(vhost
->state
!= IBMVFC_INITIALIZING
);
4330 if (vhost
->delay_init
) {
4331 vhost
->delay_init
= 0;
4332 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4336 vhost
->job_step(vhost
);
4338 case IBMVFC_HOST_ACTION_QUERY
:
4339 list_for_each_entry(tgt
, &vhost
->targets
, queue
)
4340 ibmvfc_init_tgt(tgt
, ibmvfc_tgt_query_target
);
4341 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_QUERY_TGTS
);
4343 case IBMVFC_HOST_ACTION_QUERY_TGTS
:
4344 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
4345 if (tgt
->action
== IBMVFC_TGT_ACTION_INIT
) {
4351 if (!ibmvfc_dev_init_to_do(vhost
))
4352 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_TGT_DEL
);
4354 case IBMVFC_HOST_ACTION_TGT_DEL
:
4355 case IBMVFC_HOST_ACTION_TGT_DEL_FAILED
:
4356 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
4357 if (tgt
->action
== IBMVFC_TGT_ACTION_DEL_RPORT
) {
4358 tgt_dbg(tgt
, "Deleting rport\n");
4361 list_del(&tgt
->queue
);
4362 ibmvfc_set_tgt_action(tgt
, IBMVFC_TGT_ACTION_DELETED_RPORT
);
4363 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4365 fc_remote_port_delete(rport
);
4366 del_timer_sync(&tgt
->timer
);
4367 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
4372 if (vhost
->state
== IBMVFC_INITIALIZING
) {
4373 if (vhost
->action
== IBMVFC_HOST_ACTION_TGT_DEL_FAILED
) {
4374 if (vhost
->reinit
) {
4376 scsi_block_requests(vhost
->host
);
4377 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_QUERY
);
4378 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4380 ibmvfc_set_host_state(vhost
, IBMVFC_ACTIVE
);
4381 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_NONE
);
4382 wake_up(&vhost
->init_wait_q
);
4383 schedule_work(&vhost
->rport_add_work_q
);
4384 vhost
->init_retries
= 0;
4385 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4386 scsi_unblock_requests(vhost
->host
);
4391 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_INIT
);
4392 vhost
->job_step
= ibmvfc_discover_targets
;
4395 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_NONE
);
4396 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4397 scsi_unblock_requests(vhost
->host
);
4398 wake_up(&vhost
->init_wait_q
);
4402 case IBMVFC_HOST_ACTION_ALLOC_TGTS
:
4403 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_TGT_INIT
);
4404 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4405 ibmvfc_alloc_targets(vhost
);
4406 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4408 case IBMVFC_HOST_ACTION_TGT_INIT
:
4409 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
4410 if (tgt
->action
== IBMVFC_TGT_ACTION_INIT
) {
4416 if (!ibmvfc_dev_init_to_do(vhost
))
4417 ibmvfc_set_host_action(vhost
, IBMVFC_HOST_ACTION_TGT_DEL_FAILED
);
4423 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4427 * ibmvfc_work - Do task level work
4428 * @data: ibmvfc host struct
4433 static int ibmvfc_work(void *data
)
4435 struct ibmvfc_host
*vhost
= data
;
4438 set_user_nice(current
, -20);
4441 rc
= wait_event_interruptible(vhost
->work_wait_q
,
4442 ibmvfc_work_to_do(vhost
));
4446 if (kthread_should_stop())
4449 ibmvfc_do_work(vhost
);
4452 ibmvfc_dbg(vhost
, "ibmvfc kthread exiting...\n");
4457 * ibmvfc_init_crq - Initializes and registers CRQ with hypervisor
4458 * @vhost: ibmvfc host struct
4460 * Allocates a page for messages, maps it for dma, and registers
4461 * the crq with the hypervisor.
4464 * zero on success / other on failure
4466 static int ibmvfc_init_crq(struct ibmvfc_host
*vhost
)
4468 int rc
, retrc
= -ENOMEM
;
4469 struct device
*dev
= vhost
->dev
;
4470 struct vio_dev
*vdev
= to_vio_dev(dev
);
4471 struct ibmvfc_crq_queue
*crq
= &vhost
->crq
;
4474 crq
->msgs
= (struct ibmvfc_crq
*)get_zeroed_page(GFP_KERNEL
);
4479 crq
->size
= PAGE_SIZE
/ sizeof(*crq
->msgs
);
4480 crq
->msg_token
= dma_map_single(dev
, crq
->msgs
,
4481 PAGE_SIZE
, DMA_BIDIRECTIONAL
);
4483 if (dma_mapping_error(dev
, crq
->msg_token
))
4486 retrc
= rc
= plpar_hcall_norets(H_REG_CRQ
, vdev
->unit_address
,
4487 crq
->msg_token
, PAGE_SIZE
);
4489 if (rc
== H_RESOURCE
)
4490 /* maybe kexecing and resource is busy. try a reset */
4491 retrc
= rc
= ibmvfc_reset_crq(vhost
);
4494 dev_warn(dev
, "Partner adapter not ready\n");
4496 dev_warn(dev
, "Error %d opening adapter\n", rc
);
4497 goto reg_crq_failed
;
4502 tasklet_init(&vhost
->tasklet
, (void *)ibmvfc_tasklet
, (unsigned long)vhost
);
4504 if ((rc
= request_irq(vdev
->irq
, ibmvfc_interrupt
, 0, IBMVFC_NAME
, vhost
))) {
4505 dev_err(dev
, "Couldn't register irq 0x%x. rc=%d\n", vdev
->irq
, rc
);
4506 goto req_irq_failed
;
4509 if ((rc
= vio_enable_interrupts(vdev
))) {
4510 dev_err(dev
, "Error %d enabling interrupts\n", rc
);
4511 goto req_irq_failed
;
4519 tasklet_kill(&vhost
->tasklet
);
4521 rc
= plpar_hcall_norets(H_FREE_CRQ
, vdev
->unit_address
);
4522 } while (rc
== H_BUSY
|| H_IS_LONG_BUSY(rc
));
4524 dma_unmap_single(dev
, crq
->msg_token
, PAGE_SIZE
, DMA_BIDIRECTIONAL
);
4526 free_page((unsigned long)crq
->msgs
);
4531 * ibmvfc_free_mem - Free memory for vhost
4532 * @vhost: ibmvfc host struct
4537 static void ibmvfc_free_mem(struct ibmvfc_host
*vhost
)
4539 struct ibmvfc_async_crq_queue
*async_q
= &vhost
->async_crq
;
4542 mempool_destroy(vhost
->tgt_pool
);
4543 kfree(vhost
->trace
);
4544 dma_free_coherent(vhost
->dev
, vhost
->disc_buf_sz
, vhost
->disc_buf
,
4545 vhost
->disc_buf_dma
);
4546 dma_free_coherent(vhost
->dev
, sizeof(*vhost
->login_buf
),
4547 vhost
->login_buf
, vhost
->login_buf_dma
);
4548 dma_pool_destroy(vhost
->sg_pool
);
4549 dma_unmap_single(vhost
->dev
, async_q
->msg_token
,
4550 async_q
->size
* sizeof(*async_q
->msgs
), DMA_BIDIRECTIONAL
);
4551 free_page((unsigned long)async_q
->msgs
);
4556 * ibmvfc_alloc_mem - Allocate memory for vhost
4557 * @vhost: ibmvfc host struct
4560 * 0 on success / non-zero on failure
4562 static int ibmvfc_alloc_mem(struct ibmvfc_host
*vhost
)
4564 struct ibmvfc_async_crq_queue
*async_q
= &vhost
->async_crq
;
4565 struct device
*dev
= vhost
->dev
;
4568 async_q
->msgs
= (struct ibmvfc_async_crq
*)get_zeroed_page(GFP_KERNEL
);
4569 if (!async_q
->msgs
) {
4570 dev_err(dev
, "Couldn't allocate async queue.\n");
4574 async_q
->size
= PAGE_SIZE
/ sizeof(struct ibmvfc_async_crq
);
4575 async_q
->msg_token
= dma_map_single(dev
, async_q
->msgs
,
4576 async_q
->size
* sizeof(*async_q
->msgs
),
4579 if (dma_mapping_error(dev
, async_q
->msg_token
)) {
4580 dev_err(dev
, "Failed to map async queue\n");
4581 goto free_async_crq
;
4584 vhost
->sg_pool
= dma_pool_create(IBMVFC_NAME
, dev
,
4585 SG_ALL
* sizeof(struct srp_direct_buf
),
4586 sizeof(struct srp_direct_buf
), 0);
4588 if (!vhost
->sg_pool
) {
4589 dev_err(dev
, "Failed to allocate sg pool\n");
4590 goto unmap_async_crq
;
4593 vhost
->login_buf
= dma_alloc_coherent(dev
, sizeof(*vhost
->login_buf
),
4594 &vhost
->login_buf_dma
, GFP_KERNEL
);
4596 if (!vhost
->login_buf
) {
4597 dev_err(dev
, "Couldn't allocate NPIV login buffer\n");
4601 vhost
->disc_buf_sz
= sizeof(vhost
->disc_buf
->scsi_id
[0]) * max_targets
;
4602 vhost
->disc_buf
= dma_alloc_coherent(dev
, vhost
->disc_buf_sz
,
4603 &vhost
->disc_buf_dma
, GFP_KERNEL
);
4605 if (!vhost
->disc_buf
) {
4606 dev_err(dev
, "Couldn't allocate Discover Targets buffer\n");
4607 goto free_login_buffer
;
4610 vhost
->trace
= kcalloc(IBMVFC_NUM_TRACE_ENTRIES
,
4611 sizeof(struct ibmvfc_trace_entry
), GFP_KERNEL
);
4614 goto free_disc_buffer
;
4616 vhost
->tgt_pool
= mempool_create_kmalloc_pool(IBMVFC_TGT_MEMPOOL_SZ
,
4617 sizeof(struct ibmvfc_target
));
4619 if (!vhost
->tgt_pool
) {
4620 dev_err(dev
, "Couldn't allocate target memory pool\n");
4628 kfree(vhost
->trace
);
4630 dma_free_coherent(dev
, vhost
->disc_buf_sz
, vhost
->disc_buf
,
4631 vhost
->disc_buf_dma
);
4633 dma_free_coherent(dev
, sizeof(*vhost
->login_buf
),
4634 vhost
->login_buf
, vhost
->login_buf_dma
);
4636 dma_pool_destroy(vhost
->sg_pool
);
4638 dma_unmap_single(dev
, async_q
->msg_token
,
4639 async_q
->size
* sizeof(*async_q
->msgs
), DMA_BIDIRECTIONAL
);
4641 free_page((unsigned long)async_q
->msgs
);
4648 * ibmvfc_rport_add_thread - Worker thread for rport adds
4649 * @work: work struct
4652 static void ibmvfc_rport_add_thread(struct work_struct
*work
)
4654 struct ibmvfc_host
*vhost
= container_of(work
, struct ibmvfc_host
,
4656 struct ibmvfc_target
*tgt
;
4657 struct fc_rport
*rport
;
4658 unsigned long flags
;
4662 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4665 if (vhost
->state
!= IBMVFC_ACTIVE
)
4668 list_for_each_entry(tgt
, &vhost
->targets
, queue
) {
4669 if (tgt
->add_rport
) {
4672 kref_get(&tgt
->kref
);
4675 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4676 ibmvfc_tgt_add_rport(tgt
);
4677 } else if (get_device(&rport
->dev
)) {
4678 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4679 tgt_dbg(tgt
, "Setting rport roles\n");
4680 fc_remote_port_rolechg(rport
, tgt
->ids
.roles
);
4681 put_device(&rport
->dev
);
4684 kref_put(&tgt
->kref
, ibmvfc_release_tgt
);
4685 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4691 if (vhost
->state
== IBMVFC_ACTIVE
)
4692 vhost
->scan_complete
= 1;
4693 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4698 * ibmvfc_probe - Adapter hot plug add entry point
4699 * @vdev: vio device struct
4700 * @id: vio device id struct
4703 * 0 on success / non-zero on failure
4705 static int ibmvfc_probe(struct vio_dev
*vdev
, const struct vio_device_id
*id
)
4707 struct ibmvfc_host
*vhost
;
4708 struct Scsi_Host
*shost
;
4709 struct device
*dev
= &vdev
->dev
;
4713 shost
= scsi_host_alloc(&driver_template
, sizeof(*vhost
));
4715 dev_err(dev
, "Couldn't allocate host data\n");
4719 shost
->transportt
= ibmvfc_transport_template
;
4720 shost
->can_queue
= max_requests
;
4721 shost
->max_lun
= max_lun
;
4722 shost
->max_id
= max_targets
;
4723 shost
->max_sectors
= IBMVFC_MAX_SECTORS
;
4724 shost
->max_cmd_len
= IBMVFC_MAX_CDB_LEN
;
4725 shost
->unique_id
= shost
->host_no
;
4727 vhost
= shost_priv(shost
);
4728 INIT_LIST_HEAD(&vhost
->sent
);
4729 INIT_LIST_HEAD(&vhost
->free
);
4730 INIT_LIST_HEAD(&vhost
->targets
);
4731 sprintf(vhost
->name
, IBMVFC_NAME
);
4732 vhost
->host
= shost
;
4734 vhost
->partition_number
= -1;
4735 vhost
->log_level
= log_level
;
4736 vhost
->task_set
= 1;
4737 strcpy(vhost
->partition_name
, "UNKNOWN");
4738 init_waitqueue_head(&vhost
->work_wait_q
);
4739 init_waitqueue_head(&vhost
->init_wait_q
);
4740 INIT_WORK(&vhost
->rport_add_work_q
, ibmvfc_rport_add_thread
);
4741 mutex_init(&vhost
->passthru_mutex
);
4743 if ((rc
= ibmvfc_alloc_mem(vhost
)))
4744 goto free_scsi_host
;
4746 vhost
->work_thread
= kthread_run(ibmvfc_work
, vhost
, "%s_%d", IBMVFC_NAME
,
4749 if (IS_ERR(vhost
->work_thread
)) {
4750 dev_err(dev
, "Couldn't create kernel thread: %ld\n",
4751 PTR_ERR(vhost
->work_thread
));
4755 if ((rc
= ibmvfc_init_crq(vhost
))) {
4756 dev_err(dev
, "Couldn't initialize crq. rc=%d\n", rc
);
4760 if ((rc
= ibmvfc_init_event_pool(vhost
))) {
4761 dev_err(dev
, "Couldn't initialize event pool. rc=%d\n", rc
);
4765 if ((rc
= scsi_add_host(shost
, dev
)))
4766 goto release_event_pool
;
4768 fc_host_dev_loss_tmo(shost
) = IBMVFC_DEV_LOSS_TMO
;
4770 if ((rc
= ibmvfc_create_trace_file(&shost
->shost_dev
.kobj
,
4771 &ibmvfc_trace_attr
))) {
4772 dev_err(dev
, "Failed to create trace file. rc=%d\n", rc
);
4776 if (shost_to_fc_host(shost
)->rqst_q
)
4777 blk_queue_max_segments(shost_to_fc_host(shost
)->rqst_q
, 1);
4778 dev_set_drvdata(dev
, vhost
);
4779 spin_lock(&ibmvfc_driver_lock
);
4780 list_add_tail(&vhost
->queue
, &ibmvfc_head
);
4781 spin_unlock(&ibmvfc_driver_lock
);
4783 ibmvfc_send_crq_init(vhost
);
4784 scsi_scan_host(shost
);
4788 scsi_remove_host(shost
);
4790 ibmvfc_free_event_pool(vhost
);
4792 ibmvfc_release_crq_queue(vhost
);
4794 kthread_stop(vhost
->work_thread
);
4796 ibmvfc_free_mem(vhost
);
4798 scsi_host_put(shost
);
4805 * ibmvfc_remove - Adapter hot plug remove entry point
4806 * @vdev: vio device struct
4811 static int ibmvfc_remove(struct vio_dev
*vdev
)
4813 struct ibmvfc_host
*vhost
= dev_get_drvdata(&vdev
->dev
);
4814 unsigned long flags
;
4817 ibmvfc_remove_trace_file(&vhost
->host
->shost_dev
.kobj
, &ibmvfc_trace_attr
);
4819 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4820 ibmvfc_link_down(vhost
, IBMVFC_HOST_OFFLINE
);
4821 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4823 ibmvfc_wait_while_resetting(vhost
);
4824 ibmvfc_release_crq_queue(vhost
);
4825 kthread_stop(vhost
->work_thread
);
4826 fc_remove_host(vhost
->host
);
4827 scsi_remove_host(vhost
->host
);
4829 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4830 ibmvfc_purge_requests(vhost
, DID_ERROR
);
4831 ibmvfc_free_event_pool(vhost
);
4832 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4834 ibmvfc_free_mem(vhost
);
4835 spin_lock(&ibmvfc_driver_lock
);
4836 list_del(&vhost
->queue
);
4837 spin_unlock(&ibmvfc_driver_lock
);
4838 scsi_host_put(vhost
->host
);
4844 * ibmvfc_resume - Resume from suspend
4845 * @dev: device struct
4847 * We may have lost an interrupt across suspend/resume, so kick the
4851 static int ibmvfc_resume(struct device
*dev
)
4853 unsigned long flags
;
4854 struct ibmvfc_host
*vhost
= dev_get_drvdata(dev
);
4855 struct vio_dev
*vdev
= to_vio_dev(dev
);
4857 spin_lock_irqsave(vhost
->host
->host_lock
, flags
);
4858 vio_disable_interrupts(vdev
);
4859 tasklet_schedule(&vhost
->tasklet
);
4860 spin_unlock_irqrestore(vhost
->host
->host_lock
, flags
);
4865 * ibmvfc_get_desired_dma - Calculate DMA resources needed by the driver
4866 * @vdev: vio device struct
4869 * Number of bytes the driver will need to DMA map at the same time in
4870 * order to perform well.
4872 static unsigned long ibmvfc_get_desired_dma(struct vio_dev
*vdev
)
4874 unsigned long pool_dma
= max_requests
* sizeof(union ibmvfc_iu
);
4875 return pool_dma
+ ((512 * 1024) * driver_template
.cmd_per_lun
);
4878 static struct vio_device_id ibmvfc_device_table
[] __devinitdata
= {
4879 {"fcp", "IBM,vfc-client"},
4882 MODULE_DEVICE_TABLE(vio
, ibmvfc_device_table
);
4884 static struct dev_pm_ops ibmvfc_pm_ops
= {
4885 .resume
= ibmvfc_resume
4888 static struct vio_driver ibmvfc_driver
= {
4889 .id_table
= ibmvfc_device_table
,
4890 .probe
= ibmvfc_probe
,
4891 .remove
= ibmvfc_remove
,
4892 .get_desired_dma
= ibmvfc_get_desired_dma
,
4894 .name
= IBMVFC_NAME
,
4895 .owner
= THIS_MODULE
,
4896 .pm
= &ibmvfc_pm_ops
,
4900 static struct fc_function_template ibmvfc_transport_functions
= {
4901 .show_host_fabric_name
= 1,
4902 .show_host_node_name
= 1,
4903 .show_host_port_name
= 1,
4904 .show_host_supported_classes
= 1,
4905 .show_host_port_type
= 1,
4906 .show_host_port_id
= 1,
4907 .show_host_maxframe_size
= 1,
4909 .get_host_port_state
= ibmvfc_get_host_port_state
,
4910 .show_host_port_state
= 1,
4912 .get_host_speed
= ibmvfc_get_host_speed
,
4913 .show_host_speed
= 1,
4915 .issue_fc_host_lip
= ibmvfc_issue_fc_host_lip
,
4916 .terminate_rport_io
= ibmvfc_terminate_rport_io
,
4918 .show_rport_maxframe_size
= 1,
4919 .show_rport_supported_classes
= 1,
4921 .set_rport_dev_loss_tmo
= ibmvfc_set_rport_dev_loss_tmo
,
4922 .show_rport_dev_loss_tmo
= 1,
4924 .get_starget_node_name
= ibmvfc_get_starget_node_name
,
4925 .show_starget_node_name
= 1,
4927 .get_starget_port_name
= ibmvfc_get_starget_port_name
,
4928 .show_starget_port_name
= 1,
4930 .get_starget_port_id
= ibmvfc_get_starget_port_id
,
4931 .show_starget_port_id
= 1,
4933 .bsg_request
= ibmvfc_bsg_request
,
4934 .bsg_timeout
= ibmvfc_bsg_timeout
,
4938 * ibmvfc_module_init - Initialize the ibmvfc module
4941 * 0 on success / other on failure
4943 static int __init
ibmvfc_module_init(void)
4947 if (!firmware_has_feature(FW_FEATURE_VIO
))
4950 printk(KERN_INFO IBMVFC_NAME
": IBM Virtual Fibre Channel Driver version: %s %s\n",
4951 IBMVFC_DRIVER_VERSION
, IBMVFC_DRIVER_DATE
);
4953 ibmvfc_transport_template
= fc_attach_transport(&ibmvfc_transport_functions
);
4954 if (!ibmvfc_transport_template
)
4957 rc
= vio_register_driver(&ibmvfc_driver
);
4959 fc_release_transport(ibmvfc_transport_template
);
4964 * ibmvfc_module_exit - Teardown the ibmvfc module
4969 static void __exit
ibmvfc_module_exit(void)
4971 vio_unregister_driver(&ibmvfc_driver
);
4972 fc_release_transport(ibmvfc_transport_template
);
4975 module_init(ibmvfc_module_init
);
4976 module_exit(ibmvfc_module_exit
);