?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / scsi / ibmvscsi / ibmvfc.c
blob42e4d35e0d3556985e1685c642c9cfcb04f84930
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * ibmvfc.c -- driver for IBM Power Virtual Fibre Channel Adapter
4 *
5 * Written By: Brian King <brking@linux.vnet.ibm.com>, IBM Corporation
6 *
7 * Copyright (C) IBM Corporation, 2008
8 */
9
10 #include <linux/module.h>
11 #include <linux/moduleparam.h>
12 #include <linux/dma-mapping.h>
13 #include <linux/dmapool.h>
14 #include <linux/delay.h>
15 #include <linux/interrupt.h>
16 #include <linux/kthread.h>
17 #include <linux/slab.h>
18 #include <linux/of.h>
19 #include <linux/pm.h>
20 #include <linux/stringify.h>
21 #include <linux/bsg-lib.h>
22 #include <asm/firmware.h>
23 #include <asm/irq.h>
24 #include <asm/vio.h>
25 #include <scsi/scsi.h>
26 #include <scsi/scsi_cmnd.h>
27 #include <scsi/scsi_host.h>
28 #include <scsi/scsi_device.h>
29 #include <scsi/scsi_tcq.h>
30 #include <scsi/scsi_transport_fc.h>
31 #include <scsi/scsi_bsg_fc.h>
32 #include "ibmvfc.h"
33
34 static unsigned int init_timeout = IBMVFC_INIT_TIMEOUT;
35 static unsigned int default_timeout = IBMVFC_DEFAULT_TIMEOUT;
36 static u64 max_lun = IBMVFC_MAX_LUN;
37 static unsigned int max_targets = IBMVFC_MAX_TARGETS;
38 static unsigned int max_requests = IBMVFC_MAX_REQUESTS_DEFAULT;
39 static unsigned int disc_threads = IBMVFC_MAX_DISC_THREADS;
40 static unsigned int ibmvfc_debug = IBMVFC_DEBUG;
41 static unsigned int log_level = IBMVFC_DEFAULT_LOG_LEVEL;
42 static unsigned int cls3_error = IBMVFC_CLS3_ERROR;
43 static LIST_HEAD(ibmvfc_head);
44 static DEFINE_SPINLOCK(ibmvfc_driver_lock);
45 static struct scsi_transport_template *ibmvfc_transport_template;
46
47 MODULE_DESCRIPTION("IBM Virtual Fibre Channel Driver");
48 MODULE_AUTHOR("Brian King <brking@linux.vnet.ibm.com>");
49 MODULE_LICENSE("GPL");
50 MODULE_VERSION(IBMVFC_DRIVER_VERSION);
51
52 module_param_named(init_timeout, init_timeout, uint, S_IRUGO | S_IWUSR);
53 MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds. "
54 "[Default=" __stringify(IBMVFC_INIT_TIMEOUT) "]");
55 module_param_named(default_timeout, default_timeout, uint, S_IRUGO | S_IWUSR);
56 MODULE_PARM_DESC(default_timeout,
57 "Default timeout in seconds for initialization and EH commands. "
58 "[Default=" __stringify(IBMVFC_DEFAULT_TIMEOUT) "]");
59 module_param_named(max_requests, max_requests, uint, S_IRUGO);
60 MODULE_PARM_DESC(max_requests, "Maximum requests for this adapter. "
61 "[Default=" __stringify(IBMVFC_MAX_REQUESTS_DEFAULT) "]");
62 module_param_named(max_lun, max_lun, ullong, S_IRUGO);
63 MODULE_PARM_DESC(max_lun, "Maximum allowed LUN. "
64 "[Default=" __stringify(IBMVFC_MAX_LUN) "]");
65 module_param_named(max_targets, max_targets, uint, S_IRUGO);
66 MODULE_PARM_DESC(max_targets, "Maximum allowed targets. "
67 "[Default=" __stringify(IBMVFC_MAX_TARGETS) "]");
68 module_param_named(disc_threads, disc_threads, uint, S_IRUGO);
69 MODULE_PARM_DESC(disc_threads, "Number of device discovery threads to use. "
70 "[Default=" __stringify(IBMVFC_MAX_DISC_THREADS) "]");
71 module_param_named(debug, ibmvfc_debug, uint, S_IRUGO | S_IWUSR);
72 MODULE_PARM_DESC(debug, "Enable driver debug information. "
73 "[Default=" __stringify(IBMVFC_DEBUG) "]");
74 module_param_named(log_level, log_level, uint, 0);
75 MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver. "
76 "[Default=" __stringify(IBMVFC_DEFAULT_LOG_LEVEL) "]");
77 module_param_named(cls3_error, cls3_error, uint, 0);
78 MODULE_PARM_DESC(cls3_error, "Enable FC Class 3 Error Recovery. "
79 "[Default=" __stringify(IBMVFC_CLS3_ERROR) "]");
80
81 static const struct {
82 u16 status;
83 u16 error;
84 u8 result;
85 u8 retry;
86 int log;
87 char *name;
88 } cmd_status [] = {
89 { IBMVFC_FABRIC_MAPPED, IBMVFC_UNABLE_TO_ESTABLISH, DID_ERROR, 1, 1, "unable to establish" },
90 { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_FAULT, DID_OK, 1, 0, "transport fault" },
91 { IBMVFC_FABRIC_MAPPED, IBMVFC_CMD_TIMEOUT, DID_TIME_OUT, 1, 1, "command timeout" },
92 { IBMVFC_FABRIC_MAPPED, IBMVFC_ENETDOWN, DID_TRANSPORT_DISRUPTED, 1, 1, "network down" },
93 { IBMVFC_FABRIC_MAPPED, IBMVFC_HW_FAILURE, DID_ERROR, 1, 1, "hardware failure" },
94 { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_DOWN_ERR, DID_REQUEUE, 0, 0, "link down" },
95 { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_DEAD_ERR, DID_ERROR, 0, 0, "link dead" },
96 { IBMVFC_FABRIC_MAPPED, IBMVFC_UNABLE_TO_REGISTER, DID_ERROR, 1, 1, "unable to register" },
97 { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_BUSY, DID_BUS_BUSY, 1, 0, "transport busy" },
98 { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_DEAD, DID_ERROR, 0, 1, "transport dead" },
99 { IBMVFC_FABRIC_MAPPED, IBMVFC_CONFIG_ERROR, DID_ERROR, 1, 1, "configuration error" },
100 { IBMVFC_FABRIC_MAPPED, IBMVFC_NAME_SERVER_FAIL, DID_ERROR, 1, 1, "name server failure" },
101 { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_HALTED, DID_REQUEUE, 1, 0, "link halted" },
102 { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_GENERAL, DID_OK, 1, 0, "general transport error" },
103
104 { IBMVFC_VIOS_FAILURE, IBMVFC_CRQ_FAILURE, DID_REQUEUE, 1, 1, "CRQ failure" },
105 { IBMVFC_VIOS_FAILURE, IBMVFC_SW_FAILURE, DID_ERROR, 0, 1, "software failure" },
106 { IBMVFC_VIOS_FAILURE, IBMVFC_INVALID_PARAMETER, DID_ERROR, 0, 1, "invalid parameter" },
107 { IBMVFC_VIOS_FAILURE, IBMVFC_MISSING_PARAMETER, DID_ERROR, 0, 1, "missing parameter" },
108 { IBMVFC_VIOS_FAILURE, IBMVFC_HOST_IO_BUS, DID_ERROR, 1, 1, "host I/O bus failure" },
109 { IBMVFC_VIOS_FAILURE, IBMVFC_TRANS_CANCELLED, DID_ERROR, 0, 1, "transaction cancelled" },
110 { IBMVFC_VIOS_FAILURE, IBMVFC_TRANS_CANCELLED_IMPLICIT, DID_ERROR, 0, 1, "transaction cancelled implicit" },
111 { IBMVFC_VIOS_FAILURE, IBMVFC_INSUFFICIENT_RESOURCE, DID_REQUEUE, 1, 1, "insufficient resources" },
112 { IBMVFC_VIOS_FAILURE, IBMVFC_PLOGI_REQUIRED, DID_ERROR, 0, 1, "port login required" },
113 { IBMVFC_VIOS_FAILURE, IBMVFC_COMMAND_FAILED, DID_ERROR, 1, 1, "command failed" },
114
115 { IBMVFC_FC_FAILURE, IBMVFC_INVALID_ELS_CMD_CODE, DID_ERROR, 0, 1, "invalid ELS command code" },
116 { IBMVFC_FC_FAILURE, IBMVFC_INVALID_VERSION, DID_ERROR, 0, 1, "invalid version level" },
117 { IBMVFC_FC_FAILURE, IBMVFC_LOGICAL_ERROR, DID_ERROR, 1, 1, "logical error" },
118 { IBMVFC_FC_FAILURE, IBMVFC_INVALID_CT_IU_SIZE, DID_ERROR, 0, 1, "invalid CT_IU size" },
119 { IBMVFC_FC_FAILURE, IBMVFC_LOGICAL_BUSY, DID_REQUEUE, 1, 0, "logical busy" },
120 { IBMVFC_FC_FAILURE, IBMVFC_PROTOCOL_ERROR, DID_ERROR, 1, 1, "protocol error" },
121 { IBMVFC_FC_FAILURE, IBMVFC_UNABLE_TO_PERFORM_REQ, DID_ERROR, 1, 1, "unable to perform request" },
122 { IBMVFC_FC_FAILURE, IBMVFC_CMD_NOT_SUPPORTED, DID_ERROR, 0, 0, "command not supported" },
123 { IBMVFC_FC_FAILURE, IBMVFC_SERVER_NOT_AVAIL, DID_ERROR, 0, 1, "server not available" },
124 { IBMVFC_FC_FAILURE, IBMVFC_CMD_IN_PROGRESS, DID_ERROR, 0, 1, "command already in progress" },
125 { IBMVFC_FC_FAILURE, IBMVFC_VENDOR_SPECIFIC, DID_ERROR, 1, 1, "vendor specific" },
126
127 { IBMVFC_FC_SCSI_ERROR, 0, DID_OK, 1, 0, "SCSI error" },
128 { IBMVFC_FC_SCSI_ERROR, IBMVFC_COMMAND_FAILED, DID_ERROR, 0, 1, "PRLI to device failed." },
129 };
130
131 static void ibmvfc_npiv_login(struct ibmvfc_host *);
132 static void ibmvfc_tgt_send_prli(struct ibmvfc_target *);
133 static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *);
134 static void ibmvfc_tgt_query_target(struct ibmvfc_target *);
135 static void ibmvfc_npiv_logout(struct ibmvfc_host *);
136 static void ibmvfc_tgt_implicit_logout_and_del(struct ibmvfc_target *);
137 static void ibmvfc_tgt_move_login(struct ibmvfc_target *);
138
139 static const char *unknown_error = "unknown error";
140
141 static int ibmvfc_check_caps(struct ibmvfc_host *vhost, unsigned long cap_flags)
142 {
143 u64 host_caps = be64_to_cpu(vhost->login_buf->resp.capabilities);
144
145 return (host_caps & cap_flags) ? 1 : 0;
146 }
147
148 static struct ibmvfc_fcp_cmd_iu *ibmvfc_get_fcp_iu(struct ibmvfc_host *vhost,
149 struct ibmvfc_cmd *vfc_cmd)
150 {
151 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN))
152 return &vfc_cmd->v2.iu;
153 else
154 return &vfc_cmd->v1.iu;
155 }
156
157 static struct ibmvfc_fcp_rsp *ibmvfc_get_fcp_rsp(struct ibmvfc_host *vhost,
158 struct ibmvfc_cmd *vfc_cmd)
159 {
160 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN))
161 return &vfc_cmd->v2.rsp;
162 else
163 return &vfc_cmd->v1.rsp;
164 }
165
166 #ifdef CONFIG_SCSI_IBMVFC_TRACE
167 /**
168 * ibmvfc_trc_start - Log a start trace entry
169 * @evt: ibmvfc event struct
170 *
171 **/
172 static void ibmvfc_trc_start(struct ibmvfc_event *evt)
173 {
174 struct ibmvfc_host *vhost = evt->vhost;
175 struct ibmvfc_cmd *vfc_cmd = &evt->iu.cmd;
176 struct ibmvfc_mad_common *mad = &evt->iu.mad_common;
177 struct ibmvfc_fcp_cmd_iu *iu = ibmvfc_get_fcp_iu(vhost, vfc_cmd);
178 struct ibmvfc_trace_entry *entry;
179
180 entry = &vhost->trace[vhost->trace_index++];
181 entry->evt = evt;
182 entry->time = jiffies;
183 entry->fmt = evt->crq.format;
184 entry->type = IBMVFC_TRC_START;
185
186 switch (entry->fmt) {
187 case IBMVFC_CMD_FORMAT:
188 entry->op_code = iu->cdb[0];
189 entry->scsi_id = be64_to_cpu(vfc_cmd->tgt_scsi_id);
190 entry->lun = scsilun_to_int(&iu->lun);
191 entry->tmf_flags = iu->tmf_flags;
192 entry->u.start.xfer_len = be32_to_cpu(iu->xfer_len);
193 break;
194 case IBMVFC_MAD_FORMAT:
195 entry->op_code = be32_to_cpu(mad->opcode);
196 break;
197 default:
198 break;
199 }
200 }
201
202 /**
203 * ibmvfc_trc_end - Log an end trace entry
204 * @evt: ibmvfc event struct
205 *
206 **/
207 static void ibmvfc_trc_end(struct ibmvfc_event *evt)
208 {
209 struct ibmvfc_host *vhost = evt->vhost;
210 struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
211 struct ibmvfc_mad_common *mad = &evt->xfer_iu->mad_common;
212 struct ibmvfc_fcp_cmd_iu *iu = ibmvfc_get_fcp_iu(vhost, vfc_cmd);
213 struct ibmvfc_fcp_rsp *rsp = ibmvfc_get_fcp_rsp(vhost, vfc_cmd);
214 struct ibmvfc_trace_entry *entry = &vhost->trace[vhost->trace_index++];
215
216 entry->evt = evt;
217 entry->time = jiffies;
218 entry->fmt = evt->crq.format;
219 entry->type = IBMVFC_TRC_END;
220
221 switch (entry->fmt) {
222 case IBMVFC_CMD_FORMAT:
223 entry->op_code = iu->cdb[0];
224 entry->scsi_id = be64_to_cpu(vfc_cmd->tgt_scsi_id);
225 entry->lun = scsilun_to_int(&iu->lun);
226 entry->tmf_flags = iu->tmf_flags;
227 entry->u.end.status = be16_to_cpu(vfc_cmd->status);
228 entry->u.end.error = be16_to_cpu(vfc_cmd->error);
229 entry->u.end.fcp_rsp_flags = rsp->flags;
230 entry->u.end.rsp_code = rsp->data.info.rsp_code;
231 entry->u.end.scsi_status = rsp->scsi_status;
232 break;
233 case IBMVFC_MAD_FORMAT:
234 entry->op_code = be32_to_cpu(mad->opcode);
235 entry->u.end.status = be16_to_cpu(mad->status);
236 break;
237 default:
238 break;
239
240 }
241 }
242
243 #else
244 #define ibmvfc_trc_start(evt) do { } while (0)
245 #define ibmvfc_trc_end(evt) do { } while (0)
246 #endif
247
248 /**
249 * ibmvfc_get_err_index - Find the index into cmd_status for the fcp response
250 * @status: status / error class
251 * @error: error
252 *
253 * Return value:
254 * index into cmd_status / -EINVAL on failure
255 **/
256 static int ibmvfc_get_err_index(u16 status, u16 error)
257 {
258 int i;
259
260 for (i = 0; i < ARRAY_SIZE(cmd_status); i++)
261 if ((cmd_status[i].status & status) == cmd_status[i].status &&
262 cmd_status[i].error == error)
263 return i;
264
265 return -EINVAL;
266 }
267
268 /**
269 * ibmvfc_get_cmd_error - Find the error description for the fcp response
270 * @status: status / error class
271 * @error: error
272 *
273 * Return value:
274 * error description string
275 **/
276 static const char *ibmvfc_get_cmd_error(u16 status, u16 error)
277 {
278 int rc = ibmvfc_get_err_index(status, error);
279 if (rc >= 0)
280 return cmd_status[rc].name;
281 return unknown_error;
282 }
283
284 /**
285 * ibmvfc_get_err_result - Find the scsi status to return for the fcp response
286 * @vfc_cmd: ibmvfc command struct
287 *
288 * Return value:
289 * SCSI result value to return for completed command
290 **/
291 static int ibmvfc_get_err_result(struct ibmvfc_host *vhost, struct ibmvfc_cmd *vfc_cmd)
292 {
293 int err;
294 struct ibmvfc_fcp_rsp *rsp = ibmvfc_get_fcp_rsp(vhost, vfc_cmd);
295 int fc_rsp_len = be32_to_cpu(rsp->fcp_rsp_len);
296
297 if ((rsp->flags & FCP_RSP_LEN_VALID) &&
298 ((fc_rsp_len && fc_rsp_len != 4 && fc_rsp_len != 8) ||
299 rsp->data.info.rsp_code))
300 return DID_ERROR << 16;
301
302 err = ibmvfc_get_err_index(be16_to_cpu(vfc_cmd->status), be16_to_cpu(vfc_cmd->error));
303 if (err >= 0)
304 return rsp->scsi_status | (cmd_status[err].result << 16);
305 return rsp->scsi_status | (DID_ERROR << 16);
306 }
307
308 /**
309 * ibmvfc_retry_cmd - Determine if error status is retryable
310 * @status: status / error class
311 * @error: error
312 *
313 * Return value:
314 * 1 if error should be retried / 0 if it should not
315 **/
316 static int ibmvfc_retry_cmd(u16 status, u16 error)
317 {
318 int rc = ibmvfc_get_err_index(status, error);
319
320 if (rc >= 0)
321 return cmd_status[rc].retry;
322 return 1;
323 }
324
325 static const char *unknown_fc_explain = "unknown fc explain";
326
327 static const struct {
328 u16 fc_explain;
329 char *name;
330 } ls_explain [] = {
331 { 0x00, "no additional explanation" },
332 { 0x01, "service parameter error - options" },
333 { 0x03, "service parameter error - initiator control" },
334 { 0x05, "service parameter error - recipient control" },
335 { 0x07, "service parameter error - received data field size" },
336 { 0x09, "service parameter error - concurrent seq" },
337 { 0x0B, "service parameter error - credit" },
338 { 0x0D, "invalid N_Port/F_Port_Name" },
339 { 0x0E, "invalid node/Fabric Name" },
340 { 0x0F, "invalid common service parameters" },
341 { 0x11, "invalid association header" },
342 { 0x13, "association header required" },
343 { 0x15, "invalid originator S_ID" },
344 { 0x17, "invalid OX_ID-RX-ID combination" },
345 { 0x19, "command (request) already in progress" },
346 { 0x1E, "N_Port Login requested" },
347 { 0x1F, "Invalid N_Port_ID" },
348 };
349
350 static const struct {
351 u16 fc_explain;
352 char *name;
353 } gs_explain [] = {
354 { 0x00, "no additional explanation" },
355 { 0x01, "port identifier not registered" },
356 { 0x02, "port name not registered" },
357 { 0x03, "node name not registered" },
358 { 0x04, "class of service not registered" },
359 { 0x06, "initial process associator not registered" },
360 { 0x07, "FC-4 TYPEs not registered" },
361 { 0x08, "symbolic port name not registered" },
362 { 0x09, "symbolic node name not registered" },
363 { 0x0A, "port type not registered" },
364 { 0xF0, "authorization exception" },
365 { 0xF1, "authentication exception" },
366 { 0xF2, "data base full" },
367 { 0xF3, "data base empty" },
368 { 0xF4, "processing request" },
369 { 0xF5, "unable to verify connection" },
370 { 0xF6, "devices not in a common zone" },
371 };
372
373 /**
374 * ibmvfc_get_ls_explain - Return the FC Explain description text
375 * @status: FC Explain status
376 *
377 * Returns:
378 * error string
379 **/
380 static const char *ibmvfc_get_ls_explain(u16 status)
381 {
382 int i;
383
384 for (i = 0; i < ARRAY_SIZE(ls_explain); i++)
385 if (ls_explain[i].fc_explain == status)
386 return ls_explain[i].name;
387
388 return unknown_fc_explain;
389 }
390
391 /**
392 * ibmvfc_get_gs_explain - Return the FC Explain description text
393 * @status: FC Explain status
394 *
395 * Returns:
396 * error string
397 **/
398 static const char *ibmvfc_get_gs_explain(u16 status)
399 {
400 int i;
401
402 for (i = 0; i < ARRAY_SIZE(gs_explain); i++)
403 if (gs_explain[i].fc_explain == status)
404 return gs_explain[i].name;
405
406 return unknown_fc_explain;
407 }
408
409 static const struct {
410 enum ibmvfc_fc_type fc_type;
411 char *name;
412 } fc_type [] = {
413 { IBMVFC_FABRIC_REJECT, "fabric reject" },
414 { IBMVFC_PORT_REJECT, "port reject" },
415 { IBMVFC_LS_REJECT, "ELS reject" },
416 { IBMVFC_FABRIC_BUSY, "fabric busy" },
417 { IBMVFC_PORT_BUSY, "port busy" },
418 { IBMVFC_BASIC_REJECT, "basic reject" },
419 };
420
421 static const char *unknown_fc_type = "unknown fc type";
422
423 /**
424 * ibmvfc_get_fc_type - Return the FC Type description text
425 * @status: FC Type error status
426 *
427 * Returns:
428 * error string
429 **/
430 static const char *ibmvfc_get_fc_type(u16 status)
431 {
432 int i;
433
434 for (i = 0; i < ARRAY_SIZE(fc_type); i++)
435 if (fc_type[i].fc_type == status)
436 return fc_type[i].name;
437
438 return unknown_fc_type;
439 }
440
441 /**
442 * ibmvfc_set_tgt_action - Set the next init action for the target
443 * @tgt: ibmvfc target struct
444 * @action: action to perform
445 *
446 * Returns:
447 * 0 if action changed / non-zero if not changed
448 **/
449 static int ibmvfc_set_tgt_action(struct ibmvfc_target *tgt,
450 enum ibmvfc_target_action action)
451 {
452 int rc = -EINVAL;
453
454 switch (tgt->action) {
455 case IBMVFC_TGT_ACTION_LOGOUT_RPORT:
456 if (action == IBMVFC_TGT_ACTION_LOGOUT_RPORT_WAIT ||
457 action == IBMVFC_TGT_ACTION_DEL_RPORT) {
458 tgt->action = action;
459 rc = 0;
460 }
461 break;
462 case IBMVFC_TGT_ACTION_LOGOUT_RPORT_WAIT:
463 if (action == IBMVFC_TGT_ACTION_DEL_RPORT ||
464 action == IBMVFC_TGT_ACTION_DEL_AND_LOGOUT_RPORT) {
465 tgt->action = action;
466 rc = 0;
467 }
468 break;
469 case IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT:
470 if (action == IBMVFC_TGT_ACTION_LOGOUT_RPORT) {
471 tgt->action = action;
472 rc = 0;
473 }
474 break;
475 case IBMVFC_TGT_ACTION_DEL_AND_LOGOUT_RPORT:
476 if (action == IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT) {
477 tgt->action = action;
478 rc = 0;
479 }
480 break;
481 case IBMVFC_TGT_ACTION_DEL_RPORT:
482 if (action == IBMVFC_TGT_ACTION_DELETED_RPORT) {
483 tgt->action = action;
484 rc = 0;
485 }
486 break;
487 case IBMVFC_TGT_ACTION_DELETED_RPORT:
488 break;
489 default:
490 tgt->action = action;
491 rc = 0;
492 break;
493 }
494
495 if (action >= IBMVFC_TGT_ACTION_LOGOUT_RPORT)
496 tgt->add_rport = 0;
497
498 return rc;
499 }
500
501 /**
502 * ibmvfc_set_host_state - Set the state for the host
503 * @vhost: ibmvfc host struct
504 * @state: state to set host to
505 *
506 * Returns:
507 * 0 if state changed / non-zero if not changed
508 **/
509 static int ibmvfc_set_host_state(struct ibmvfc_host *vhost,
510 enum ibmvfc_host_state state)
511 {
512 int rc = 0;
513
514 switch (vhost->state) {
515 case IBMVFC_HOST_OFFLINE:
516 rc = -EINVAL;
517 break;
518 default:
519 vhost->state = state;
520 break;
521 }
522
523 return rc;
524 }
525
526 /**
527 * ibmvfc_set_host_action - Set the next init action for the host
528 * @vhost: ibmvfc host struct
529 * @action: action to perform
530 *
531 **/
532 static void ibmvfc_set_host_action(struct ibmvfc_host *vhost,
533 enum ibmvfc_host_action action)
534 {
535 switch (action) {
536 case IBMVFC_HOST_ACTION_ALLOC_TGTS:
537 if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT)
538 vhost->action = action;
539 break;
540 case IBMVFC_HOST_ACTION_LOGO_WAIT:
541 if (vhost->action == IBMVFC_HOST_ACTION_LOGO)
542 vhost->action = action;
543 break;
544 case IBMVFC_HOST_ACTION_INIT_WAIT:
545 if (vhost->action == IBMVFC_HOST_ACTION_INIT)
546 vhost->action = action;
547 break;
548 case IBMVFC_HOST_ACTION_QUERY:
549 switch (vhost->action) {
550 case IBMVFC_HOST_ACTION_INIT_WAIT:
551 case IBMVFC_HOST_ACTION_NONE:
552 case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
553 vhost->action = action;
554 break;
555 default:
556 break;
557 }
558 break;
559 case IBMVFC_HOST_ACTION_TGT_INIT:
560 if (vhost->action == IBMVFC_HOST_ACTION_ALLOC_TGTS)
561 vhost->action = action;
562 break;
563 case IBMVFC_HOST_ACTION_INIT:
564 case IBMVFC_HOST_ACTION_TGT_DEL:
565 switch (vhost->action) {
566 case IBMVFC_HOST_ACTION_RESET:
567 case IBMVFC_HOST_ACTION_REENABLE:
568 break;
569 default:
570 vhost->action = action;
571 break;
572 }
573 break;
574 case IBMVFC_HOST_ACTION_LOGO:
575 case IBMVFC_HOST_ACTION_QUERY_TGTS:
576 case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
577 case IBMVFC_HOST_ACTION_NONE:
578 case IBMVFC_HOST_ACTION_RESET:
579 case IBMVFC_HOST_ACTION_REENABLE:
580 default:
581 vhost->action = action;
582 break;
583 }
584 }
585
586 /**
587 * ibmvfc_reinit_host - Re-start host initialization (no NPIV Login)
588 * @vhost: ibmvfc host struct
589 *
590 * Return value:
591 * nothing
592 **/
593 static void ibmvfc_reinit_host(struct ibmvfc_host *vhost)
594 {
595 if (vhost->action == IBMVFC_HOST_ACTION_NONE &&
596 vhost->state == IBMVFC_ACTIVE) {
597 if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
598 scsi_block_requests(vhost->host);
599 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
600 }
601 } else
602 vhost->reinit = 1;
603
604 wake_up(&vhost->work_wait_q);
605 }
606
607 /**
608 * ibmvfc_del_tgt - Schedule cleanup and removal of the target
609 * @tgt: ibmvfc target struct
610 * @job_step: job step to perform
611 *
612 **/
613 static void ibmvfc_del_tgt(struct ibmvfc_target *tgt)
614 {
615 if (!ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_LOGOUT_RPORT))
616 tgt->job_step = ibmvfc_tgt_implicit_logout_and_del;
617 wake_up(&tgt->vhost->work_wait_q);
618 }
619
620 /**
621 * ibmvfc_link_down - Handle a link down event from the adapter
622 * @vhost: ibmvfc host struct
623 * @state: ibmvfc host state to enter
624 *
625 **/
626 static void ibmvfc_link_down(struct ibmvfc_host *vhost,
627 enum ibmvfc_host_state state)
628 {
629 struct ibmvfc_target *tgt;
630
631 ENTER;
632 scsi_block_requests(vhost->host);
633 list_for_each_entry(tgt, &vhost->targets, queue)
634 ibmvfc_del_tgt(tgt);
635 ibmvfc_set_host_state(vhost, state);
636 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
637 vhost->events_to_log |= IBMVFC_AE_LINKDOWN;
638 wake_up(&vhost->work_wait_q);
639 LEAVE;
640 }
641
642 /**
643 * ibmvfc_init_host - Start host initialization
644 * @vhost: ibmvfc host struct
645 *
646 * Return value:
647 * nothing
648 **/
649 static void ibmvfc_init_host(struct ibmvfc_host *vhost)
650 {
651 struct ibmvfc_target *tgt;
652
653 if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
654 if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
655 dev_err(vhost->dev,
656 "Host initialization retries exceeded. Taking adapter offline\n");
657 ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
658 return;
659 }
660 }
661
662 if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
663 memset(vhost->async_crq.msgs, 0, PAGE_SIZE);
664 vhost->async_crq.cur = 0;
665
666 list_for_each_entry(tgt, &vhost->targets, queue)
667 ibmvfc_del_tgt(tgt);
668 scsi_block_requests(vhost->host);
669 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
670 vhost->job_step = ibmvfc_npiv_login;
671 wake_up(&vhost->work_wait_q);
672 }
673 }
674
675 /**
676 * ibmvfc_send_crq - Send a CRQ
677 * @vhost: ibmvfc host struct
678 * @word1: the first 64 bits of the data
679 * @word2: the second 64 bits of the data
680 *
681 * Return value:
682 * 0 on success / other on failure
683 **/
684 static int ibmvfc_send_crq(struct ibmvfc_host *vhost, u64 word1, u64 word2)
685 {
686 struct vio_dev *vdev = to_vio_dev(vhost->dev);
687 return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
688 }
689
690 /**
691 * ibmvfc_send_crq_init - Send a CRQ init message
692 * @vhost: ibmvfc host struct
693 *
694 * Return value:
695 * 0 on success / other on failure
696 **/
697 static int ibmvfc_send_crq_init(struct ibmvfc_host *vhost)
698 {
699 ibmvfc_dbg(vhost, "Sending CRQ init\n");
700 return ibmvfc_send_crq(vhost, 0xC001000000000000LL, 0);
701 }
702
703 /**
704 * ibmvfc_send_crq_init_complete - Send a CRQ init complete message
705 * @vhost: ibmvfc host struct
706 *
707 * Return value:
708 * 0 on success / other on failure
709 **/
710 static int ibmvfc_send_crq_init_complete(struct ibmvfc_host *vhost)
711 {
712 ibmvfc_dbg(vhost, "Sending CRQ init complete\n");
713 return ibmvfc_send_crq(vhost, 0xC002000000000000LL, 0);
714 }
715
716 /**
717 * ibmvfc_release_crq_queue - Deallocates data and unregisters CRQ
718 * @vhost: ibmvfc host struct
719 *
720 * Frees irq, deallocates a page for messages, unmaps dma, and unregisters
721 * the crq with the hypervisor.
722 **/
723 static void ibmvfc_release_crq_queue(struct ibmvfc_host *vhost)
724 {
725 long rc = 0;
726 struct vio_dev *vdev = to_vio_dev(vhost->dev);
727 struct ibmvfc_crq_queue *crq = &vhost->crq;
728
729 ibmvfc_dbg(vhost, "Releasing CRQ\n");
730 free_irq(vdev->irq, vhost);
731 tasklet_kill(&vhost->tasklet);
732 do {
733 if (rc)
734 msleep(100);
735 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
736 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
737
738 vhost->state = IBMVFC_NO_CRQ;
739 vhost->logged_in = 0;
740 dma_unmap_single(vhost->dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
741 free_page((unsigned long)crq->msgs);
742 }
743
744 /**
745 * ibmvfc_reenable_crq_queue - reenables the CRQ
746 * @vhost: ibmvfc host struct
747 *
748 * Return value:
749 * 0 on success / other on failure
750 **/
751 static int ibmvfc_reenable_crq_queue(struct ibmvfc_host *vhost)
752 {
753 int rc = 0;
754 struct vio_dev *vdev = to_vio_dev(vhost->dev);
755
756 /* Re-enable the CRQ */
757 do {
758 if (rc)
759 msleep(100);
760 rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
761 } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc));
762
763 if (rc)
764 dev_err(vhost->dev, "Error enabling adapter (rc=%d)\n", rc);
765
766 return rc;
767 }
768
769 /**
770 * ibmvfc_reset_crq - resets a crq after a failure
771 * @vhost: ibmvfc host struct
772 *
773 * Return value:
774 * 0 on success / other on failure
775 **/
776 static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)
777 {
778 int rc = 0;
779 unsigned long flags;
780 struct vio_dev *vdev = to_vio_dev(vhost->dev);
781 struct ibmvfc_crq_queue *crq = &vhost->crq;
782
783 /* Close the CRQ */
784 do {
785 if (rc)
786 msleep(100);
787 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
788 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
789
790 spin_lock_irqsave(vhost->host->host_lock, flags);
791 vhost->state = IBMVFC_NO_CRQ;
792 vhost->logged_in = 0;
793
794 /* Clean out the queue */
795 memset(crq->msgs, 0, PAGE_SIZE);
796 crq->cur = 0;
797
798 /* And re-open it again */
799 rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
800 crq->msg_token, PAGE_SIZE);
801
802 if (rc == H_CLOSED)
803 /* Adapter is good, but other end is not ready */
804 dev_warn(vhost->dev, "Partner adapter not ready\n");
805 else if (rc != 0)
806 dev_warn(vhost->dev, "Couldn't register crq (rc=%d)\n", rc);
807 spin_unlock_irqrestore(vhost->host->host_lock, flags);
808
809 return rc;
810 }
811
812 /**
813 * ibmvfc_valid_event - Determines if event is valid.
814 * @pool: event_pool that contains the event
815 * @evt: ibmvfc event to be checked for validity
816 *
817 * Return value:
818 * 1 if event is valid / 0 if event is not valid
819 **/
820 static int ibmvfc_valid_event(struct ibmvfc_event_pool *pool,
821 struct ibmvfc_event *evt)
822 {
823 int index = evt - pool->events;
824 if (index < 0 || index >= pool->size) /* outside of bounds */
825 return 0;
826 if (evt != pool->events + index) /* unaligned */
827 return 0;
828 return 1;
829 }
830
831 /**
832 * ibmvfc_free_event - Free the specified event
833 * @evt: ibmvfc_event to be freed
834 *
835 **/
836 static void ibmvfc_free_event(struct ibmvfc_event *evt)
837 {
838 struct ibmvfc_host *vhost = evt->vhost;
839 struct ibmvfc_event_pool *pool = &vhost->pool;
840
841 BUG_ON(!ibmvfc_valid_event(pool, evt));
842 BUG_ON(atomic_inc_return(&evt->free) != 1);
843 list_add_tail(&evt->queue, &vhost->free);
844 }
845
846 /**
847 * ibmvfc_scsi_eh_done - EH done function for queuecommand commands
848 * @evt: ibmvfc event struct
849 *
850 * This function does not setup any error status, that must be done
851 * before this function gets called.
852 **/
853 static void ibmvfc_scsi_eh_done(struct ibmvfc_event *evt)
854 {
855 struct scsi_cmnd *cmnd = evt->cmnd;
856
857 if (cmnd) {
858 scsi_dma_unmap(cmnd);
859 cmnd->scsi_done(cmnd);
860 }
861
862 if (evt->eh_comp)
863 complete(evt->eh_comp);
864
865 ibmvfc_free_event(evt);
866 }
867
868 /**
869 * ibmvfc_fail_request - Fail request with specified error code
870 * @evt: ibmvfc event struct
871 * @error_code: error code to fail request with
872 *
873 * Return value:
874 * none
875 **/
876 static void ibmvfc_fail_request(struct ibmvfc_event *evt, int error_code)
877 {
878 if (evt->cmnd) {
879 evt->cmnd->result = (error_code << 16);
880 evt->done = ibmvfc_scsi_eh_done;
881 } else
882 evt->xfer_iu->mad_common.status = cpu_to_be16(IBMVFC_MAD_DRIVER_FAILED);
883
884 list_del(&evt->queue);
885 del_timer(&evt->timer);
886 ibmvfc_trc_end(evt);
887 evt->done(evt);
888 }
889
890 /**
891 * ibmvfc_purge_requests - Our virtual adapter just shut down. Purge any sent requests
892 * @vhost: ibmvfc host struct
893 * @error_code: error code to fail requests with
894 *
895 * Return value:
896 * none
897 **/
898 static void ibmvfc_purge_requests(struct ibmvfc_host *vhost, int error_code)
899 {
900 struct ibmvfc_event *evt, *pos;
901
902 ibmvfc_dbg(vhost, "Purging all requests\n");
903 list_for_each_entry_safe(evt, pos, &vhost->sent, queue)
904 ibmvfc_fail_request(evt, error_code);
905 }
906
907 /**
908 * ibmvfc_hard_reset_host - Reset the connection to the server by breaking the CRQ
909 * @vhost: struct ibmvfc host to reset
910 **/
911 static void ibmvfc_hard_reset_host(struct ibmvfc_host *vhost)
912 {
913 ibmvfc_purge_requests(vhost, DID_ERROR);
914 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
915 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_RESET);
916 }
917
918 /**
919 * __ibmvfc_reset_host - Reset the connection to the server (no locking)
920 * @vhost: struct ibmvfc host to reset
921 **/
922 static void __ibmvfc_reset_host(struct ibmvfc_host *vhost)
923 {
924 if (vhost->logged_in && vhost->action != IBMVFC_HOST_ACTION_LOGO_WAIT &&
925 !ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
926 scsi_block_requests(vhost->host);
927 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO);
928 vhost->job_step = ibmvfc_npiv_logout;
929 wake_up(&vhost->work_wait_q);
930 } else
931 ibmvfc_hard_reset_host(vhost);
932 }
933
934 /**
935 * ibmvfc_reset_host - Reset the connection to the server
936 * @vhost: ibmvfc host struct
937 **/
938 static void ibmvfc_reset_host(struct ibmvfc_host *vhost)
939 {
940 unsigned long flags;
941
942 spin_lock_irqsave(vhost->host->host_lock, flags);
943 __ibmvfc_reset_host(vhost);
944 spin_unlock_irqrestore(vhost->host->host_lock, flags);
945 }
946
947 /**
948 * ibmvfc_retry_host_init - Retry host initialization if allowed
949 * @vhost: ibmvfc host struct
950 *
951 * Returns: 1 if init will be retried / 0 if not
952 *
953 **/
954 static int ibmvfc_retry_host_init(struct ibmvfc_host *vhost)
955 {
956 int retry = 0;
957
958 if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
959 vhost->delay_init = 1;
960 if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
961 dev_err(vhost->dev,
962 "Host initialization retries exceeded. Taking adapter offline\n");
963 ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
964 } else if (vhost->init_retries == IBMVFC_MAX_HOST_INIT_RETRIES)
965 __ibmvfc_reset_host(vhost);
966 else {
967 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
968 retry = 1;
969 }
970 }
971
972 wake_up(&vhost->work_wait_q);
973 return retry;
974 }
975
976 /**
977 * __ibmvfc_get_target - Find the specified scsi_target (no locking)
978 * @starget: scsi target struct
979 *
980 * Return value:
981 * ibmvfc_target struct / NULL if not found
982 **/
983 static struct ibmvfc_target *__ibmvfc_get_target(struct scsi_target *starget)
984 {
985 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
986 struct ibmvfc_host *vhost = shost_priv(shost);
987 struct ibmvfc_target *tgt;
988
989 list_for_each_entry(tgt, &vhost->targets, queue)
990 if (tgt->target_id == starget->id) {
991 kref_get(&tgt->kref);
992 return tgt;
993 }
994 return NULL;
995 }
996
997 /**
998 * ibmvfc_get_target - Find the specified scsi_target
999 * @starget: scsi target struct
1000 *
1001 * Return value:
1002 * ibmvfc_target struct / NULL if not found
1003 **/
1004 static struct ibmvfc_target *ibmvfc_get_target(struct scsi_target *starget)
1005 {
1006 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1007 struct ibmvfc_target *tgt;
1008 unsigned long flags;
1009
1010 spin_lock_irqsave(shost->host_lock, flags);
1011 tgt = __ibmvfc_get_target(starget);
1012 spin_unlock_irqrestore(shost->host_lock, flags);
1013 return tgt;
1014 }
1015
1016 /**
1017 * ibmvfc_get_host_speed - Get host port speed
1018 * @shost: scsi host struct
1019 *
1020 * Return value:
1021 * none
1022 **/
1023 static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
1024 {
1025 struct ibmvfc_host *vhost = shost_priv(shost);
1026 unsigned long flags;
1027
1028 spin_lock_irqsave(shost->host_lock, flags);
1029 if (vhost->state == IBMVFC_ACTIVE) {
1030 switch (be64_to_cpu(vhost->login_buf->resp.link_speed) / 100) {
1031 case 1:
1032 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
1033 break;
1034 case 2:
1035 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
1036 break;
1037 case 4:
1038 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
1039 break;
1040 case 8:
1041 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
1042 break;
1043 case 10:
1044 fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
1045 break;
1046 case 16:
1047 fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
1048 break;
1049 default:
1050 ibmvfc_log(vhost, 3, "Unknown port speed: %lld Gbit\n",
1051 be64_to_cpu(vhost->login_buf->resp.link_speed) / 100);
1052 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
1053 break;
1054 }
1055 } else
1056 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
1057 spin_unlock_irqrestore(shost->host_lock, flags);
1058 }
1059
1060 /**
1061 * ibmvfc_get_host_port_state - Get host port state
1062 * @shost: scsi host struct
1063 *
1064 * Return value:
1065 * none
1066 **/
1067 static void ibmvfc_get_host_port_state(struct Scsi_Host *shost)
1068 {
1069 struct ibmvfc_host *vhost = shost_priv(shost);
1070 unsigned long flags;
1071
1072 spin_lock_irqsave(shost->host_lock, flags);
1073 switch (vhost->state) {
1074 case IBMVFC_INITIALIZING:
1075 case IBMVFC_ACTIVE:
1076 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
1077 break;
1078 case IBMVFC_LINK_DOWN:
1079 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
1080 break;
1081 case IBMVFC_LINK_DEAD:
1082 case IBMVFC_HOST_OFFLINE:
1083 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
1084 break;
1085 case IBMVFC_HALTED:
1086 fc_host_port_state(shost) = FC_PORTSTATE_BLOCKED;
1087 break;
1088 case IBMVFC_NO_CRQ:
1089 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
1090 break;
1091 default:
1092 ibmvfc_log(vhost, 3, "Unknown port state: %d\n", vhost->state);
1093 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
1094 break;
1095 }
1096 spin_unlock_irqrestore(shost->host_lock, flags);
1097 }
1098
1099 /**
1100 * ibmvfc_set_rport_dev_loss_tmo - Set rport's device loss timeout
1101 * @rport: rport struct
1102 * @timeout: timeout value
1103 *
1104 * Return value:
1105 * none
1106 **/
1107 static void ibmvfc_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
1108 {
1109 if (timeout)
1110 rport->dev_loss_tmo = timeout;
1111 else
1112 rport->dev_loss_tmo = 1;
1113 }
1114
1115 /**
1116 * ibmvfc_release_tgt - Free memory allocated for a target
1117 * @kref: kref struct
1118 *
1119 **/
1120 static void ibmvfc_release_tgt(struct kref *kref)
1121 {
1122 struct ibmvfc_target *tgt = container_of(kref, struct ibmvfc_target, kref);
1123 kfree(tgt);
1124 }
1125
1126 /**
1127 * ibmvfc_get_starget_node_name - Get SCSI target's node name
1128 * @starget: scsi target struct
1129 *
1130 * Return value:
1131 * none
1132 **/
1133 static void ibmvfc_get_starget_node_name(struct scsi_target *starget)
1134 {
1135 struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
1136 fc_starget_port_name(starget) = tgt ? tgt->ids.node_name : 0;
1137 if (tgt)
1138 kref_put(&tgt->kref, ibmvfc_release_tgt);
1139 }
1140
1141 /**
1142 * ibmvfc_get_starget_port_name - Get SCSI target's port name
1143 * @starget: scsi target struct
1144 *
1145 * Return value:
1146 * none
1147 **/
1148 static void ibmvfc_get_starget_port_name(struct scsi_target *starget)
1149 {
1150 struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
1151 fc_starget_port_name(starget) = tgt ? tgt->ids.port_name : 0;
1152 if (tgt)
1153 kref_put(&tgt->kref, ibmvfc_release_tgt);
1154 }
1155
1156 /**
1157 * ibmvfc_get_starget_port_id - Get SCSI target's port ID
1158 * @starget: scsi target struct
1159 *
1160 * Return value:
1161 * none
1162 **/
1163 static void ibmvfc_get_starget_port_id(struct scsi_target *starget)
1164 {
1165 struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
1166 fc_starget_port_id(starget) = tgt ? tgt->scsi_id : -1;
1167 if (tgt)
1168 kref_put(&tgt->kref, ibmvfc_release_tgt);
1169 }
1170
1171 /**
1172 * ibmvfc_wait_while_resetting - Wait while the host resets
1173 * @vhost: ibmvfc host struct
1174 *
1175 * Return value:
1176 * 0 on success / other on failure
1177 **/
1178 static int ibmvfc_wait_while_resetting(struct ibmvfc_host *vhost)
1179 {
1180 long timeout = wait_event_timeout(vhost->init_wait_q,
1181 ((vhost->state == IBMVFC_ACTIVE ||
1182 vhost->state == IBMVFC_HOST_OFFLINE ||
1183 vhost->state == IBMVFC_LINK_DEAD) &&
1184 vhost->action == IBMVFC_HOST_ACTION_NONE),
1185 (init_timeout * HZ));
1186
1187 return timeout ? 0 : -EIO;
1188 }
1189
1190 /**
1191 * ibmvfc_issue_fc_host_lip - Re-initiate link initialization
1192 * @shost: scsi host struct
1193 *
1194 * Return value:
1195 * 0 on success / other on failure
1196 **/
1197 static int ibmvfc_issue_fc_host_lip(struct Scsi_Host *shost)
1198 {
1199 struct ibmvfc_host *vhost = shost_priv(shost);
1200
1201 dev_err(vhost->dev, "Initiating host LIP. Resetting connection\n");
1202 ibmvfc_reset_host(vhost);
1203 return ibmvfc_wait_while_resetting(vhost);
1204 }
1205
1206 /**
1207 * ibmvfc_gather_partition_info - Gather info about the LPAR
1208 *
1209 * Return value:
1210 * none
1211 **/
1212 static void ibmvfc_gather_partition_info(struct ibmvfc_host *vhost)
1213 {
1214 struct device_node *rootdn;
1215 const char *name;
1216 const unsigned int *num;
1217
1218 rootdn = of_find_node_by_path("/");
1219 if (!rootdn)
1220 return;
1221
1222 name = of_get_property(rootdn, "ibm,partition-name", NULL);
1223 if (name)
1224 strncpy(vhost->partition_name, name, sizeof(vhost->partition_name));
1225 num = of_get_property(rootdn, "ibm,partition-no", NULL);
1226 if (num)
1227 vhost->partition_number = *num;
1228 of_node_put(rootdn);
1229 }
1230
1231 /**
1232 * ibmvfc_set_login_info - Setup info for NPIV login
1233 * @vhost: ibmvfc host struct
1234 *
1235 * Return value:
1236 * none
1237 **/
1238 static void ibmvfc_set_login_info(struct ibmvfc_host *vhost)
1239 {
1240 struct ibmvfc_npiv_login *login_info = &vhost->login_info;
1241 struct device_node *of_node = vhost->dev->of_node;
1242 const char *location;
1243
1244 memset(login_info, 0, sizeof(*login_info));
1245
1246 login_info->ostype = cpu_to_be32(IBMVFC_OS_LINUX);
1247 login_info->max_dma_len = cpu_to_be64(IBMVFC_MAX_SECTORS << 9);
1248 login_info->max_payload = cpu_to_be32(sizeof(struct ibmvfc_fcp_cmd_iu));
1249 login_info->max_response = cpu_to_be32(sizeof(struct ibmvfc_fcp_rsp));
1250 login_info->partition_num = cpu_to_be32(vhost->partition_number);
1251 login_info->vfc_frame_version = cpu_to_be32(1);
1252 login_info->fcp_version = cpu_to_be16(3);
1253 login_info->flags = cpu_to_be16(IBMVFC_FLUSH_ON_HALT);
1254 if (vhost->client_migrated)
1255 login_info->flags |= cpu_to_be16(IBMVFC_CLIENT_MIGRATED);
1256
1257 login_info->max_cmds = cpu_to_be32(max_requests + IBMVFC_NUM_INTERNAL_REQ);
1258 login_info->capabilities = cpu_to_be64(IBMVFC_CAN_MIGRATE | IBMVFC_CAN_SEND_VF_WWPN);
1259 login_info->async.va = cpu_to_be64(vhost->async_crq.msg_token);
1260 login_info->async.len = cpu_to_be32(vhost->async_crq.size * sizeof(*vhost->async_crq.msgs));
1261 strncpy(login_info->partition_name, vhost->partition_name, IBMVFC_MAX_NAME);
1262 strncpy(login_info->device_name,
1263 dev_name(&vhost->host->shost_gendev), IBMVFC_MAX_NAME);
1264
1265 location = of_get_property(of_node, "ibm,loc-code", NULL);
1266 location = location ? location : dev_name(vhost->dev);
1267 strncpy(login_info->drc_name, location, IBMVFC_MAX_NAME);
1268 }
1269
1270 /**
1271 * ibmvfc_init_event_pool - Allocates and initializes the event pool for a host
1272 * @vhost: ibmvfc host who owns the event pool
1273 *
1274 * Returns zero on success.
1275 **/
1276 static int ibmvfc_init_event_pool(struct ibmvfc_host *vhost)
1277 {
1278 int i;
1279 struct ibmvfc_event_pool *pool = &vhost->pool;
1280
1281 ENTER;
1282 pool->size = max_requests + IBMVFC_NUM_INTERNAL_REQ;
1283 pool->events = kcalloc(pool->size, sizeof(*pool->events), GFP_KERNEL);
1284 if (!pool->events)
1285 return -ENOMEM;
1286
1287 pool->iu_storage = dma_alloc_coherent(vhost->dev,
1288 pool->size * sizeof(*pool->iu_storage),
1289 &pool->iu_token, 0);
1290
1291 if (!pool->iu_storage) {
1292 kfree(pool->events);
1293 return -ENOMEM;
1294 }
1295
1296 for (i = 0; i < pool->size; ++i) {
1297 struct ibmvfc_event *evt = &pool->events[i];
1298 atomic_set(&evt->free, 1);
1299 evt->crq.valid = 0x80;
1300 evt->crq.ioba = cpu_to_be64(pool->iu_token + (sizeof(*evt->xfer_iu) * i));
1301 evt->xfer_iu = pool->iu_storage + i;
1302 evt->vhost = vhost;
1303 evt->ext_list = NULL;
1304 list_add_tail(&evt->queue, &vhost->free);
1305 }
1306
1307 LEAVE;
1308 return 0;
1309 }
1310
1311 /**
1312 * ibmvfc_free_event_pool - Frees memory of the event pool of a host
1313 * @vhost: ibmvfc host who owns the event pool
1314 *
1315 **/
1316 static void ibmvfc_free_event_pool(struct ibmvfc_host *vhost)
1317 {
1318 int i;
1319 struct ibmvfc_event_pool *pool = &vhost->pool;
1320
1321 ENTER;
1322 for (i = 0; i < pool->size; ++i) {
1323 list_del(&pool->events[i].queue);
1324 BUG_ON(atomic_read(&pool->events[i].free) != 1);
1325 if (pool->events[i].ext_list)
1326 dma_pool_free(vhost->sg_pool,
1327 pool->events[i].ext_list,
1328 pool->events[i].ext_list_token);
1329 }
1330
1331 kfree(pool->events);
1332 dma_free_coherent(vhost->dev,
1333 pool->size * sizeof(*pool->iu_storage),
1334 pool->iu_storage, pool->iu_token);
1335 LEAVE;
1336 }
1337
1338 /**
1339 * ibmvfc_get_event - Gets the next free event in pool
1340 * @vhost: ibmvfc host struct
1341 *
1342 * Returns a free event from the pool.
1343 **/
1344 static struct ibmvfc_event *ibmvfc_get_event(struct ibmvfc_host *vhost)
1345 {
1346 struct ibmvfc_event *evt;
1347
1348 BUG_ON(list_empty(&vhost->free));
1349 evt = list_entry(vhost->free.next, struct ibmvfc_event, queue);
1350 atomic_set(&evt->free, 0);
1351 list_del(&evt->queue);
1352 return evt;
1353 }
1354
1355 /**
1356 * ibmvfc_init_event - Initialize fields in an event struct that are always
1357 * required.
1358 * @evt: The event
1359 * @done: Routine to call when the event is responded to
1360 * @format: SRP or MAD format
1361 **/
1362 static void ibmvfc_init_event(struct ibmvfc_event *evt,
1363 void (*done) (struct ibmvfc_event *), u8 format)
1364 {
1365 evt->cmnd = NULL;
1366 evt->sync_iu = NULL;
1367 evt->crq.format = format;
1368 evt->done = done;
1369 evt->eh_comp = NULL;
1370 }
1371
1372 /**
1373 * ibmvfc_map_sg_list - Initialize scatterlist
1374 * @scmd: scsi command struct
1375 * @nseg: number of scatterlist segments
1376 * @md: memory descriptor list to initialize
1377 **/
1378 static void ibmvfc_map_sg_list(struct scsi_cmnd *scmd, int nseg,
1379 struct srp_direct_buf *md)
1380 {
1381 int i;
1382 struct scatterlist *sg;
1383
1384 scsi_for_each_sg(scmd, sg, nseg, i) {
1385 md[i].va = cpu_to_be64(sg_dma_address(sg));
1386 md[i].len = cpu_to_be32(sg_dma_len(sg));
1387 md[i].key = 0;
1388 }
1389 }
1390
1391 /**
1392 * ibmvfc_map_sg_data - Maps dma for a scatterlist and initializes descriptor fields
1393 * @scmd: struct scsi_cmnd with the scatterlist
1394 * @evt: ibmvfc event struct
1395 * @vfc_cmd: vfc_cmd that contains the memory descriptor
1396 * @dev: device for which to map dma memory
1397 *
1398 * Returns:
1399 * 0 on success / non-zero on failure
1400 **/
1401 static int ibmvfc_map_sg_data(struct scsi_cmnd *scmd,
1402 struct ibmvfc_event *evt,
1403 struct ibmvfc_cmd *vfc_cmd, struct device *dev)
1404 {
1405
1406 int sg_mapped;
1407 struct srp_direct_buf *data = &vfc_cmd->ioba;
1408 struct ibmvfc_host *vhost = dev_get_drvdata(dev);
1409 struct ibmvfc_fcp_cmd_iu *iu = ibmvfc_get_fcp_iu(evt->vhost, vfc_cmd);
1410
1411 if (cls3_error)
1412 vfc_cmd->flags |= cpu_to_be16(IBMVFC_CLASS_3_ERR);
1413
1414 sg_mapped = scsi_dma_map(scmd);
1415 if (!sg_mapped) {
1416 vfc_cmd->flags |= cpu_to_be16(IBMVFC_NO_MEM_DESC);
1417 return 0;
1418 } else if (unlikely(sg_mapped < 0)) {
1419 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1420 scmd_printk(KERN_ERR, scmd, "Failed to map DMA buffer for command\n");
1421 return sg_mapped;
1422 }
1423
1424 if (scmd->sc_data_direction == DMA_TO_DEVICE) {
1425 vfc_cmd->flags |= cpu_to_be16(IBMVFC_WRITE);
1426 iu->add_cdb_len |= IBMVFC_WRDATA;
1427 } else {
1428 vfc_cmd->flags |= cpu_to_be16(IBMVFC_READ);
1429 iu->add_cdb_len |= IBMVFC_RDDATA;
1430 }
1431
1432 if (sg_mapped == 1) {
1433 ibmvfc_map_sg_list(scmd, sg_mapped, data);
1434 return 0;
1435 }
1436
1437 vfc_cmd->flags |= cpu_to_be16(IBMVFC_SCATTERLIST);
1438
1439 if (!evt->ext_list) {
1440 evt->ext_list = dma_pool_alloc(vhost->sg_pool, GFP_ATOMIC,
1441 &evt->ext_list_token);
1442
1443 if (!evt->ext_list) {
1444 scsi_dma_unmap(scmd);
1445 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1446 scmd_printk(KERN_ERR, scmd, "Can't allocate memory for scatterlist\n");
1447 return -ENOMEM;
1448 }
1449 }
1450
1451 ibmvfc_map_sg_list(scmd, sg_mapped, evt->ext_list);
1452
1453 data->va = cpu_to_be64(evt->ext_list_token);
1454 data->len = cpu_to_be32(sg_mapped * sizeof(struct srp_direct_buf));
1455 data->key = 0;
1456 return 0;
1457 }
1458
1459 /**
1460 * ibmvfc_timeout - Internal command timeout handler
1461 * @evt: struct ibmvfc_event that timed out
1462 *
1463 * Called when an internally generated command times out
1464 **/
1465 static void ibmvfc_timeout(struct timer_list *t)
1466 {
1467 struct ibmvfc_event *evt = from_timer(evt, t, timer);
1468 struct ibmvfc_host *vhost = evt->vhost;
1469 dev_err(vhost->dev, "Command timed out (%p). Resetting connection\n", evt);
1470 ibmvfc_reset_host(vhost);
1471 }
1472
1473 /**
1474 * ibmvfc_send_event - Transforms event to u64 array and calls send_crq()
1475 * @evt: event to be sent
1476 * @vhost: ibmvfc host struct
1477 * @timeout: timeout in seconds - 0 means do not time command
1478 *
1479 * Returns the value returned from ibmvfc_send_crq(). (Zero for success)
1480 **/
1481 static int ibmvfc_send_event(struct ibmvfc_event *evt,
1482 struct ibmvfc_host *vhost, unsigned long timeout)
1483 {
1484 __be64 *crq_as_u64 = (__be64 *) &evt->crq;
1485 int rc;
1486
1487 /* Copy the IU into the transfer area */
1488 *evt->xfer_iu = evt->iu;
1489 if (evt->crq.format == IBMVFC_CMD_FORMAT)
1490 evt->xfer_iu->cmd.tag = cpu_to_be64((u64)evt);
1491 else if (evt->crq.format == IBMVFC_MAD_FORMAT)
1492 evt->xfer_iu->mad_common.tag = cpu_to_be64((u64)evt);
1493 else
1494 BUG();
1495
1496 list_add_tail(&evt->queue, &vhost->sent);
1497 timer_setup(&evt->timer, ibmvfc_timeout, 0);
1498
1499 if (timeout) {
1500 evt->timer.expires = jiffies + (timeout * HZ);
1501 add_timer(&evt->timer);
1502 }
1503
1504 mb();
1505
1506 if ((rc = ibmvfc_send_crq(vhost, be64_to_cpu(crq_as_u64[0]),
1507 be64_to_cpu(crq_as_u64[1])))) {
1508 list_del(&evt->queue);
1509 del_timer(&evt->timer);
1510
1511 /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY.
1512 * Firmware will send a CRQ with a transport event (0xFF) to
1513 * tell this client what has happened to the transport. This
1514 * will be handled in ibmvfc_handle_crq()
1515 */
1516 if (rc == H_CLOSED) {
1517 if (printk_ratelimit())
1518 dev_warn(vhost->dev, "Send warning. Receive queue closed, will retry.\n");
1519 if (evt->cmnd)
1520 scsi_dma_unmap(evt->cmnd);
1521 ibmvfc_free_event(evt);
1522 return SCSI_MLQUEUE_HOST_BUSY;
1523 }
1524
1525 dev_err(vhost->dev, "Send error (rc=%d)\n", rc);
1526 if (evt->cmnd) {
1527 evt->cmnd->result = DID_ERROR << 16;
1528 evt->done = ibmvfc_scsi_eh_done;
1529 } else
1530 evt->xfer_iu->mad_common.status = cpu_to_be16(IBMVFC_MAD_CRQ_ERROR);
1531
1532 evt->done(evt);
1533 } else
1534 ibmvfc_trc_start(evt);
1535
1536 return 0;
1537 }
1538
1539 /**
1540 * ibmvfc_log_error - Log an error for the failed command if appropriate
1541 * @evt: ibmvfc event to log
1542 *
1543 **/
1544 static void ibmvfc_log_error(struct ibmvfc_event *evt)
1545 {
1546 struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
1547 struct ibmvfc_host *vhost = evt->vhost;
1548 struct ibmvfc_fcp_rsp *rsp = ibmvfc_get_fcp_rsp(vhost, vfc_cmd);
1549 struct scsi_cmnd *cmnd = evt->cmnd;
1550 const char *err = unknown_error;
1551 int index = ibmvfc_get_err_index(be16_to_cpu(vfc_cmd->status), be16_to_cpu(vfc_cmd->error));
1552 int logerr = 0;
1553 int rsp_code = 0;
1554
1555 if (index >= 0) {
1556 logerr = cmd_status[index].log;
1557 err = cmd_status[index].name;
1558 }
1559
1560 if (!logerr && (vhost->log_level <= (IBMVFC_DEFAULT_LOG_LEVEL + 1)))
1561 return;
1562
1563 if (rsp->flags & FCP_RSP_LEN_VALID)
1564 rsp_code = rsp->data.info.rsp_code;
1565
1566 scmd_printk(KERN_ERR, cmnd, "Command (%02X) : %s (%x:%x) "
1567 "flags: %x fcp_rsp: %x, resid=%d, scsi_status: %x\n",
1568 cmnd->cmnd[0], err, be16_to_cpu(vfc_cmd->status), be16_to_cpu(vfc_cmd->error),
1569 rsp->flags, rsp_code, scsi_get_resid(cmnd), rsp->scsi_status);
1570 }
1571
1572 /**
1573 * ibmvfc_relogin - Log back into the specified device
1574 * @sdev: scsi device struct
1575 *
1576 **/
1577 static void ibmvfc_relogin(struct scsi_device *sdev)
1578 {
1579 struct ibmvfc_host *vhost = shost_priv(sdev->host);
1580 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
1581 struct ibmvfc_target *tgt;
1582
1583 list_for_each_entry(tgt, &vhost->targets, queue) {
1584 if (rport == tgt->rport) {
1585 ibmvfc_del_tgt(tgt);
1586 break;
1587 }
1588 }
1589
1590 ibmvfc_reinit_host(vhost);
1591 }
1592
1593 /**
1594 * ibmvfc_scsi_done - Handle responses from commands
1595 * @evt: ibmvfc event to be handled
1596 *
1597 * Used as a callback when sending scsi cmds.
1598 **/
1599 static void ibmvfc_scsi_done(struct ibmvfc_event *evt)
1600 {
1601 struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
1602 struct ibmvfc_fcp_rsp *rsp = ibmvfc_get_fcp_rsp(evt->vhost, vfc_cmd);
1603 struct scsi_cmnd *cmnd = evt->cmnd;
1604 u32 rsp_len = 0;
1605 u32 sense_len = be32_to_cpu(rsp->fcp_sense_len);
1606
1607 if (cmnd) {
1608 if (be16_to_cpu(vfc_cmd->response_flags) & IBMVFC_ADAPTER_RESID_VALID)
1609 scsi_set_resid(cmnd, be32_to_cpu(vfc_cmd->adapter_resid));
1610 else if (rsp->flags & FCP_RESID_UNDER)
1611 scsi_set_resid(cmnd, be32_to_cpu(rsp->fcp_resid));
1612 else
1613 scsi_set_resid(cmnd, 0);
1614
1615 if (vfc_cmd->status) {
1616 cmnd->result = ibmvfc_get_err_result(evt->vhost, vfc_cmd);
1617
1618 if (rsp->flags & FCP_RSP_LEN_VALID)
1619 rsp_len = be32_to_cpu(rsp->fcp_rsp_len);
1620 if ((sense_len + rsp_len) > SCSI_SENSE_BUFFERSIZE)
1621 sense_len = SCSI_SENSE_BUFFERSIZE - rsp_len;
1622 if ((rsp->flags & FCP_SNS_LEN_VALID) && rsp->fcp_sense_len && rsp_len <= 8)
1623 memcpy(cmnd->sense_buffer, rsp->data.sense + rsp_len, sense_len);
1624 if ((be16_to_cpu(vfc_cmd->status) & IBMVFC_VIOS_FAILURE) &&
1625 (be16_to_cpu(vfc_cmd->error) == IBMVFC_PLOGI_REQUIRED))
1626 ibmvfc_relogin(cmnd->device);
1627
1628 if (!cmnd->result && (!scsi_get_resid(cmnd) || (rsp->flags & FCP_RESID_OVER)))
1629 cmnd->result = (DID_ERROR << 16);
1630
1631 ibmvfc_log_error(evt);
1632 }
1633
1634 if (!cmnd->result &&
1635 (scsi_bufflen(cmnd) - scsi_get_resid(cmnd) < cmnd->underflow))
1636 cmnd->result = (DID_ERROR << 16);
1637
1638 scsi_dma_unmap(cmnd);
1639 cmnd->scsi_done(cmnd);
1640 }
1641
1642 if (evt->eh_comp)
1643 complete(evt->eh_comp);
1644
1645 ibmvfc_free_event(evt);
1646 }
1647
1648 /**
1649 * ibmvfc_host_chkready - Check if the host can accept commands
1650 * @vhost: struct ibmvfc host
1651 *
1652 * Returns:
1653 * 1 if host can accept command / 0 if not
1654 **/
1655 static inline int ibmvfc_host_chkready(struct ibmvfc_host *vhost)
1656 {
1657 int result = 0;
1658
1659 switch (vhost->state) {
1660 case IBMVFC_LINK_DEAD:
1661 case IBMVFC_HOST_OFFLINE:
1662 result = DID_NO_CONNECT << 16;
1663 break;
1664 case IBMVFC_NO_CRQ:
1665 case IBMVFC_INITIALIZING:
1666 case IBMVFC_HALTED:
1667 case IBMVFC_LINK_DOWN:
1668 result = DID_REQUEUE << 16;
1669 break;
1670 case IBMVFC_ACTIVE:
1671 result = 0;
1672 break;
1673 }
1674
1675 return result;
1676 }
1677
1678 static struct ibmvfc_cmd *ibmvfc_init_vfc_cmd(struct ibmvfc_event *evt, struct scsi_device *sdev)
1679 {
1680 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
1681 struct ibmvfc_host *vhost = evt->vhost;
1682 struct ibmvfc_cmd *vfc_cmd = &evt->iu.cmd;
1683 struct ibmvfc_fcp_cmd_iu *iu = ibmvfc_get_fcp_iu(vhost, vfc_cmd);
1684 struct ibmvfc_fcp_rsp *rsp = ibmvfc_get_fcp_rsp(vhost, vfc_cmd);
1685 size_t offset;
1686
1687 memset(vfc_cmd, 0, sizeof(*vfc_cmd));
1688 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN)) {
1689 offset = offsetof(struct ibmvfc_cmd, v2.rsp);
1690 vfc_cmd->target_wwpn = cpu_to_be64(rport->port_name);
1691 } else
1692 offset = offsetof(struct ibmvfc_cmd, v1.rsp);
1693 vfc_cmd->resp.va = cpu_to_be64(be64_to_cpu(evt->crq.ioba) + offset);
1694 vfc_cmd->resp.len = cpu_to_be32(sizeof(*rsp));
1695 vfc_cmd->frame_type = cpu_to_be32(IBMVFC_SCSI_FCP_TYPE);
1696 vfc_cmd->payload_len = cpu_to_be32(sizeof(*iu));
1697 vfc_cmd->resp_len = cpu_to_be32(sizeof(*rsp));
1698 vfc_cmd->cancel_key = cpu_to_be32((unsigned long)sdev->hostdata);
1699 vfc_cmd->tgt_scsi_id = cpu_to_be64(rport->port_id);
1700 int_to_scsilun(sdev->lun, &iu->lun);
1701
1702 return vfc_cmd;
1703 }
1704
1705 /**
1706 * ibmvfc_queuecommand - The queuecommand function of the scsi template
1707 * @cmnd: struct scsi_cmnd to be executed
1708 * @done: Callback function to be called when cmnd is completed
1709 *
1710 * Returns:
1711 * 0 on success / other on failure
1712 **/
1713 static int ibmvfc_queuecommand_lck(struct scsi_cmnd *cmnd,
1714 void (*done) (struct scsi_cmnd *))
1715 {
1716 struct ibmvfc_host *vhost = shost_priv(cmnd->device->host);
1717 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
1718 struct ibmvfc_cmd *vfc_cmd;
1719 struct ibmvfc_fcp_cmd_iu *iu;
1720 struct ibmvfc_event *evt;
1721 int rc;
1722
1723 if (unlikely((rc = fc_remote_port_chkready(rport))) ||
1724 unlikely((rc = ibmvfc_host_chkready(vhost)))) {
1725 cmnd->result = rc;
1726 done(cmnd);
1727 return 0;
1728 }
1729
1730 cmnd->result = (DID_OK << 16);
1731 evt = ibmvfc_get_event(vhost);
1732 ibmvfc_init_event(evt, ibmvfc_scsi_done, IBMVFC_CMD_FORMAT);
1733 evt->cmnd = cmnd;
1734 cmnd->scsi_done = done;
1735
1736 vfc_cmd = ibmvfc_init_vfc_cmd(evt, cmnd->device);
1737 iu = ibmvfc_get_fcp_iu(vhost, vfc_cmd);
1738
1739 iu->xfer_len = cpu_to_be32(scsi_bufflen(cmnd));
1740 memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
1741
1742 if (cmnd->flags & SCMD_TAGGED) {
1743 vfc_cmd->task_tag = cpu_to_be64(cmnd->tag);
1744 iu->pri_task_attr = IBMVFC_SIMPLE_TASK;
1745 }
1746
1747 vfc_cmd->correlation = cpu_to_be64(evt);
1748
1749 if (likely(!(rc = ibmvfc_map_sg_data(cmnd, evt, vfc_cmd, vhost->dev))))
1750 return ibmvfc_send_event(evt, vhost, 0);
1751
1752 ibmvfc_free_event(evt);
1753 if (rc == -ENOMEM)
1754 return SCSI_MLQUEUE_HOST_BUSY;
1755
1756 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1757 scmd_printk(KERN_ERR, cmnd,
1758 "Failed to map DMA buffer for command. rc=%d\n", rc);
1759
1760 cmnd->result = DID_ERROR << 16;
1761 done(cmnd);
1762 return 0;
1763 }
1764
1765 static DEF_SCSI_QCMD(ibmvfc_queuecommand)
1766
1767 /**
1768 * ibmvfc_sync_completion - Signal that a synchronous command has completed
1769 * @evt: ibmvfc event struct
1770 *
1771 **/
1772 static void ibmvfc_sync_completion(struct ibmvfc_event *evt)
1773 {
1774 /* copy the response back */
1775 if (evt->sync_iu)
1776 *evt->sync_iu = *evt->xfer_iu;
1777
1778 complete(&evt->comp);
1779 }
1780
1781 /**
1782 * ibmvfc_bsg_timeout_done - Completion handler for cancelling BSG commands
1783 * @evt: struct ibmvfc_event
1784 *
1785 **/
1786 static void ibmvfc_bsg_timeout_done(struct ibmvfc_event *evt)
1787 {
1788 struct ibmvfc_host *vhost = evt->vhost;
1789
1790 ibmvfc_free_event(evt);
1791 vhost->aborting_passthru = 0;
1792 dev_info(vhost->dev, "Passthru command cancelled\n");
1793 }
1794
1795 /**
1796 * ibmvfc_bsg_timeout - Handle a BSG timeout
1797 * @job: struct bsg_job that timed out
1798 *
1799 * Returns:
1800 * 0 on success / other on failure
1801 **/
1802 static int ibmvfc_bsg_timeout(struct bsg_job *job)
1803 {
1804 struct ibmvfc_host *vhost = shost_priv(fc_bsg_to_shost(job));
1805 unsigned long port_id = (unsigned long)job->dd_data;
1806 struct ibmvfc_event *evt;
1807 struct ibmvfc_tmf *tmf;
1808 unsigned long flags;
1809 int rc;
1810
1811 ENTER;
1812 spin_lock_irqsave(vhost->host->host_lock, flags);
1813 if (vhost->aborting_passthru || vhost->state != IBMVFC_ACTIVE) {
1814 __ibmvfc_reset_host(vhost);
1815 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1816 return 0;
1817 }
1818
1819 vhost->aborting_passthru = 1;
1820 evt = ibmvfc_get_event(vhost);
1821 ibmvfc_init_event(evt, ibmvfc_bsg_timeout_done, IBMVFC_MAD_FORMAT);
1822
1823 tmf = &evt->iu.tmf;
1824 memset(tmf, 0, sizeof(*tmf));
1825 tmf->common.version = cpu_to_be32(1);
1826 tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD);
1827 tmf->common.length = cpu_to_be16(sizeof(*tmf));
1828 tmf->scsi_id = cpu_to_be64(port_id);
1829 tmf->cancel_key = cpu_to_be32(IBMVFC_PASSTHRU_CANCEL_KEY);
1830 tmf->my_cancel_key = cpu_to_be32(IBMVFC_INTERNAL_CANCEL_KEY);
1831 rc = ibmvfc_send_event(evt, vhost, default_timeout);
1832
1833 if (rc != 0) {
1834 vhost->aborting_passthru = 0;
1835 dev_err(vhost->dev, "Failed to send cancel event. rc=%d\n", rc);
1836 rc = -EIO;
1837 } else
1838 dev_info(vhost->dev, "Cancelling passthru command to port id 0x%lx\n",
1839 port_id);
1840
1841 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1842
1843 LEAVE;
1844 return rc;
1845 }
1846
1847 /**
1848 * ibmvfc_bsg_plogi - PLOGI into a target to handle a BSG command
1849 * @vhost: struct ibmvfc_host to send command
1850 * @port_id: port ID to send command
1851 *
1852 * Returns:
1853 * 0 on success / other on failure
1854 **/
1855 static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
1856 {
1857 struct ibmvfc_port_login *plogi;
1858 struct ibmvfc_target *tgt;
1859 struct ibmvfc_event *evt;
1860 union ibmvfc_iu rsp_iu;
1861 unsigned long flags;
1862 int rc = 0, issue_login = 1;
1863
1864 ENTER;
1865 spin_lock_irqsave(vhost->host->host_lock, flags);
1866 list_for_each_entry(tgt, &vhost->targets, queue) {
1867 if (tgt->scsi_id == port_id) {
1868 issue_login = 0;
1869 break;
1870 }
1871 }
1872
1873 if (!issue_login)
1874 goto unlock_out;
1875 if (unlikely((rc = ibmvfc_host_chkready(vhost))))
1876 goto unlock_out;
1877
1878 evt = ibmvfc_get_event(vhost);
1879 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
1880 plogi = &evt->iu.plogi;
1881 memset(plogi, 0, sizeof(*plogi));
1882 plogi->common.version = cpu_to_be32(1);
1883 plogi->common.opcode = cpu_to_be32(IBMVFC_PORT_LOGIN);
1884 plogi->common.length = cpu_to_be16(sizeof(*plogi));
1885 plogi->scsi_id = cpu_to_be64(port_id);
1886 evt->sync_iu = &rsp_iu;
1887 init_completion(&evt->comp);
1888
1889 rc = ibmvfc_send_event(evt, vhost, default_timeout);
1890 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1891
1892 if (rc)
1893 return -EIO;
1894
1895 wait_for_completion(&evt->comp);
1896
1897 if (rsp_iu.plogi.common.status)
1898 rc = -EIO;
1899
1900 spin_lock_irqsave(vhost->host->host_lock, flags);
1901 ibmvfc_free_event(evt);
1902 unlock_out:
1903 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1904 LEAVE;
1905 return rc;
1906 }
1907
1908 /**
1909 * ibmvfc_bsg_request - Handle a BSG request
1910 * @job: struct bsg_job to be executed
1911 *
1912 * Returns:
1913 * 0 on success / other on failure
1914 **/
1915 static int ibmvfc_bsg_request(struct bsg_job *job)
1916 {
1917 struct ibmvfc_host *vhost = shost_priv(fc_bsg_to_shost(job));
1918 struct fc_rport *rport = fc_bsg_to_rport(job);
1919 struct ibmvfc_passthru_mad *mad;
1920 struct ibmvfc_event *evt;
1921 union ibmvfc_iu rsp_iu;
1922 unsigned long flags, port_id = -1;
1923 struct fc_bsg_request *bsg_request = job->request;
1924 struct fc_bsg_reply *bsg_reply = job->reply;
1925 unsigned int code = bsg_request->msgcode;
1926 int rc = 0, req_seg, rsp_seg, issue_login = 0;
1927 u32 fc_flags, rsp_len;
1928
1929 ENTER;
1930 bsg_reply->reply_payload_rcv_len = 0;
1931 if (rport)
1932 port_id = rport->port_id;
1933
1934 switch (code) {
1935 case FC_BSG_HST_ELS_NOLOGIN:
1936 port_id = (bsg_request->rqst_data.h_els.port_id[0] << 16) |
1937 (bsg_request->rqst_data.h_els.port_id[1] << 8) |
1938 bsg_request->rqst_data.h_els.port_id[2];
1939 fallthrough;
1940 case FC_BSG_RPT_ELS:
1941 fc_flags = IBMVFC_FC_ELS;
1942 break;
1943 case FC_BSG_HST_CT:
1944 issue_login = 1;
1945 port_id = (bsg_request->rqst_data.h_ct.port_id[0] << 16) |
1946 (bsg_request->rqst_data.h_ct.port_id[1] << 8) |
1947 bsg_request->rqst_data.h_ct.port_id[2];
1948 fallthrough;
1949 case FC_BSG_RPT_CT:
1950 fc_flags = IBMVFC_FC_CT_IU;
1951 break;
1952 default:
1953 return -ENOTSUPP;
1954 }
1955
1956 if (port_id == -1)
1957 return -EINVAL;
1958 if (!mutex_trylock(&vhost->passthru_mutex))
1959 return -EBUSY;
1960
1961 job->dd_data = (void *)port_id;
1962 req_seg = dma_map_sg(vhost->dev, job->request_payload.sg_list,
1963 job->request_payload.sg_cnt, DMA_TO_DEVICE);
1964
1965 if (!req_seg) {
1966 mutex_unlock(&vhost->passthru_mutex);
1967 return -ENOMEM;
1968 }
1969
1970 rsp_seg = dma_map_sg(vhost->dev, job->reply_payload.sg_list,
1971 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
1972
1973 if (!rsp_seg) {
1974 dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
1975 job->request_payload.sg_cnt, DMA_TO_DEVICE);
1976 mutex_unlock(&vhost->passthru_mutex);
1977 return -ENOMEM;
1978 }
1979
1980 if (req_seg > 1 || rsp_seg > 1) {
1981 rc = -EINVAL;
1982 goto out;
1983 }
1984
1985 if (issue_login)
1986 rc = ibmvfc_bsg_plogi(vhost, port_id);
1987
1988 spin_lock_irqsave(vhost->host->host_lock, flags);
1989
1990 if (unlikely(rc || (rport && (rc = fc_remote_port_chkready(rport)))) ||
1991 unlikely((rc = ibmvfc_host_chkready(vhost)))) {
1992 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1993 goto out;
1994 }
1995
1996 evt = ibmvfc_get_event(vhost);
1997 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
1998 mad = &evt->iu.passthru;
1999
2000 memset(mad, 0, sizeof(*mad));
2001 mad->common.version = cpu_to_be32(1);
2002 mad->common.opcode = cpu_to_be32(IBMVFC_PASSTHRU);
2003 mad->common.length = cpu_to_be16(sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu));
2004
2005 mad->cmd_ioba.va = cpu_to_be64(be64_to_cpu(evt->crq.ioba) +
2006 offsetof(struct ibmvfc_passthru_mad, iu));
2007 mad->cmd_ioba.len = cpu_to_be32(sizeof(mad->iu));
2008
2009 mad->iu.cmd_len = cpu_to_be32(job->request_payload.payload_len);
2010 mad->iu.rsp_len = cpu_to_be32(job->reply_payload.payload_len);
2011 mad->iu.flags = cpu_to_be32(fc_flags);
2012 mad->iu.cancel_key = cpu_to_be32(IBMVFC_PASSTHRU_CANCEL_KEY);
2013
2014 mad->iu.cmd.va = cpu_to_be64(sg_dma_address(job->request_payload.sg_list));
2015 mad->iu.cmd.len = cpu_to_be32(sg_dma_len(job->request_payload.sg_list));
2016 mad->iu.rsp.va = cpu_to_be64(sg_dma_address(job->reply_payload.sg_list));
2017 mad->iu.rsp.len = cpu_to_be32(sg_dma_len(job->reply_payload.sg_list));
2018 mad->iu.scsi_id = cpu_to_be64(port_id);
2019 mad->iu.tag = cpu_to_be64((u64)evt);
2020 rsp_len = be32_to_cpu(mad->iu.rsp.len);
2021
2022 evt->sync_iu = &rsp_iu;
2023 init_completion(&evt->comp);
2024 rc = ibmvfc_send_event(evt, vhost, 0);
2025 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2026
2027 if (rc) {
2028 rc = -EIO;
2029 goto out;
2030 }
2031
2032 wait_for_completion(&evt->comp);
2033
2034 if (rsp_iu.passthru.common.status)
2035 rc = -EIO;
2036 else
2037 bsg_reply->reply_payload_rcv_len = rsp_len;
2038
2039 spin_lock_irqsave(vhost->host->host_lock, flags);
2040 ibmvfc_free_event(evt);
2041 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2042 bsg_reply->result = rc;
2043 bsg_job_done(job, bsg_reply->result,
2044 bsg_reply->reply_payload_rcv_len);
2045 rc = 0;
2046 out:
2047 dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
2048 job->request_payload.sg_cnt, DMA_TO_DEVICE);
2049 dma_unmap_sg(vhost->dev, job->reply_payload.sg_list,
2050 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
2051 mutex_unlock(&vhost->passthru_mutex);
2052 LEAVE;
2053 return rc;
2054 }
2055
2056 /**
2057 * ibmvfc_reset_device - Reset the device with the specified reset type
2058 * @sdev: scsi device to reset
2059 * @type: reset type
2060 * @desc: reset type description for log messages
2061 *
2062 * Returns:
2063 * 0 on success / other on failure
2064 **/
2065 static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
2066 {
2067 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2068 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2069 struct ibmvfc_cmd *tmf;
2070 struct ibmvfc_event *evt = NULL;
2071 union ibmvfc_iu rsp_iu;
2072 struct ibmvfc_fcp_cmd_iu *iu;
2073 struct ibmvfc_fcp_rsp *fc_rsp = ibmvfc_get_fcp_rsp(vhost, &rsp_iu.cmd);
2074 int rsp_rc = -EBUSY;
2075 unsigned long flags;
2076 int rsp_code = 0;
2077
2078 spin_lock_irqsave(vhost->host->host_lock, flags);
2079 if (vhost->state == IBMVFC_ACTIVE) {
2080 evt = ibmvfc_get_event(vhost);
2081 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
2082 tmf = ibmvfc_init_vfc_cmd(evt, sdev);
2083 iu = ibmvfc_get_fcp_iu(vhost, tmf);
2084
2085 tmf->flags = cpu_to_be16((IBMVFC_NO_MEM_DESC | IBMVFC_TMF));
2086 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN))
2087 tmf->target_wwpn = cpu_to_be64(rport->port_name);
2088 iu->tmf_flags = type;
2089 evt->sync_iu = &rsp_iu;
2090
2091 init_completion(&evt->comp);
2092 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
2093 }
2094 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2095
2096 if (rsp_rc != 0) {
2097 sdev_printk(KERN_ERR, sdev, "Failed to send %s reset event. rc=%d\n",
2098 desc, rsp_rc);
2099 return -EIO;
2100 }
2101
2102 sdev_printk(KERN_INFO, sdev, "Resetting %s\n", desc);
2103 wait_for_completion(&evt->comp);
2104
2105 if (rsp_iu.cmd.status)
2106 rsp_code = ibmvfc_get_err_result(vhost, &rsp_iu.cmd);
2107
2108 if (rsp_code) {
2109 if (fc_rsp->flags & FCP_RSP_LEN_VALID)
2110 rsp_code = fc_rsp->data.info.rsp_code;
2111
2112 sdev_printk(KERN_ERR, sdev, "%s reset failed: %s (%x:%x) "
2113 "flags: %x fcp_rsp: %x, scsi_status: %x\n", desc,
2114 ibmvfc_get_cmd_error(be16_to_cpu(rsp_iu.cmd.status), be16_to_cpu(rsp_iu.cmd.error)),
2115 be16_to_cpu(rsp_iu.cmd.status), be16_to_cpu(rsp_iu.cmd.error), fc_rsp->flags, rsp_code,
2116 fc_rsp->scsi_status);
2117 rsp_rc = -EIO;
2118 } else
2119 sdev_printk(KERN_INFO, sdev, "%s reset successful\n", desc);
2120
2121 spin_lock_irqsave(vhost->host->host_lock, flags);
2122 ibmvfc_free_event(evt);
2123 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2124 return rsp_rc;
2125 }
2126
2127 /**
2128 * ibmvfc_match_rport - Match function for specified remote port
2129 * @evt: ibmvfc event struct
2130 * @device: device to match (rport)
2131 *
2132 * Returns:
2133 * 1 if event matches rport / 0 if event does not match rport
2134 **/
2135 static int ibmvfc_match_rport(struct ibmvfc_event *evt, void *rport)
2136 {
2137 struct fc_rport *cmd_rport;
2138
2139 if (evt->cmnd) {
2140 cmd_rport = starget_to_rport(scsi_target(evt->cmnd->device));
2141 if (cmd_rport == rport)
2142 return 1;
2143 }
2144 return 0;
2145 }
2146
2147 /**
2148 * ibmvfc_match_target - Match function for specified target
2149 * @evt: ibmvfc event struct
2150 * @device: device to match (starget)
2151 *
2152 * Returns:
2153 * 1 if event matches starget / 0 if event does not match starget
2154 **/
2155 static int ibmvfc_match_target(struct ibmvfc_event *evt, void *device)
2156 {
2157 if (evt->cmnd && scsi_target(evt->cmnd->device) == device)
2158 return 1;
2159 return 0;
2160 }
2161
2162 /**
2163 * ibmvfc_match_lun - Match function for specified LUN
2164 * @evt: ibmvfc event struct
2165 * @device: device to match (sdev)
2166 *
2167 * Returns:
2168 * 1 if event matches sdev / 0 if event does not match sdev
2169 **/
2170 static int ibmvfc_match_lun(struct ibmvfc_event *evt, void *device)
2171 {
2172 if (evt->cmnd && evt->cmnd->device == device)
2173 return 1;
2174 return 0;
2175 }
2176
2177 /**
2178 * ibmvfc_wait_for_ops - Wait for ops to complete
2179 * @vhost: ibmvfc host struct
2180 * @device: device to match (starget or sdev)
2181 * @match: match function
2182 *
2183 * Returns:
2184 * SUCCESS / FAILED
2185 **/
2186 static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
2187 int (*match) (struct ibmvfc_event *, void *))
2188 {
2189 struct ibmvfc_event *evt;
2190 DECLARE_COMPLETION_ONSTACK(comp);
2191 int wait;
2192 unsigned long flags;
2193 signed long timeout = IBMVFC_ABORT_WAIT_TIMEOUT * HZ;
2194
2195 ENTER;
2196 do {
2197 wait = 0;
2198 spin_lock_irqsave(vhost->host->host_lock, flags);
2199 list_for_each_entry(evt, &vhost->sent, queue) {
2200 if (match(evt, device)) {
2201 evt->eh_comp = &comp;
2202 wait++;
2203 }
2204 }
2205 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2206
2207 if (wait) {
2208 timeout = wait_for_completion_timeout(&comp, timeout);
2209
2210 if (!timeout) {
2211 wait = 0;
2212 spin_lock_irqsave(vhost->host->host_lock, flags);
2213 list_for_each_entry(evt, &vhost->sent, queue) {
2214 if (match(evt, device)) {
2215 evt->eh_comp = NULL;
2216 wait++;
2217 }
2218 }
2219 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2220 if (wait)
2221 dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
2222 LEAVE;
2223 return wait ? FAILED : SUCCESS;
2224 }
2225 }
2226 } while (wait);
2227
2228 LEAVE;
2229 return SUCCESS;
2230 }
2231
2232 /**
2233 * ibmvfc_cancel_all - Cancel all outstanding commands to the device
2234 * @sdev: scsi device to cancel commands
2235 * @type: type of error recovery being performed
2236 *
2237 * This sends a cancel to the VIOS for the specified device. This does
2238 * NOT send any abort to the actual device. That must be done separately.
2239 *
2240 * Returns:
2241 * 0 on success / other on failure
2242 **/
2243 static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
2244 {
2245 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2246 struct scsi_target *starget = scsi_target(sdev);
2247 struct fc_rport *rport = starget_to_rport(starget);
2248 struct ibmvfc_tmf *tmf;
2249 struct ibmvfc_event *evt, *found_evt;
2250 union ibmvfc_iu rsp;
2251 int rsp_rc = -EBUSY;
2252 unsigned long flags;
2253 u16 status;
2254
2255 ENTER;
2256 spin_lock_irqsave(vhost->host->host_lock, flags);
2257 found_evt = NULL;
2258 list_for_each_entry(evt, &vhost->sent, queue) {
2259 if (evt->cmnd && evt->cmnd->device == sdev) {
2260 found_evt = evt;
2261 break;
2262 }
2263 }
2264
2265 if (!found_evt) {
2266 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
2267 sdev_printk(KERN_INFO, sdev, "No events found to cancel\n");
2268 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2269 return 0;
2270 }
2271
2272 if (vhost->logged_in) {
2273 evt = ibmvfc_get_event(vhost);
2274 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
2275
2276 tmf = &evt->iu.tmf;
2277 memset(tmf, 0, sizeof(*tmf));
2278 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN)) {
2279 tmf->common.version = cpu_to_be32(2);
2280 tmf->target_wwpn = cpu_to_be64(rport->port_name);
2281 } else {
2282 tmf->common.version = cpu_to_be32(1);
2283 }
2284 tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD);
2285 tmf->common.length = cpu_to_be16(sizeof(*tmf));
2286 tmf->scsi_id = cpu_to_be64(rport->port_id);
2287 int_to_scsilun(sdev->lun, &tmf->lun);
2288 if (!ibmvfc_check_caps(vhost, IBMVFC_CAN_SUPPRESS_ABTS))
2289 type &= ~IBMVFC_TMF_SUPPRESS_ABTS;
2290 if (vhost->state == IBMVFC_ACTIVE)
2291 tmf->flags = cpu_to_be32((type | IBMVFC_TMF_LUA_VALID));
2292 else
2293 tmf->flags = cpu_to_be32(((type & IBMVFC_TMF_SUPPRESS_ABTS) | IBMVFC_TMF_LUA_VALID));
2294 tmf->cancel_key = cpu_to_be32((unsigned long)sdev->hostdata);
2295 tmf->my_cancel_key = cpu_to_be32((unsigned long)starget->hostdata);
2296
2297 evt->sync_iu = &rsp;
2298 init_completion(&evt->comp);
2299 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
2300 }
2301
2302 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2303
2304 if (rsp_rc != 0) {
2305 sdev_printk(KERN_ERR, sdev, "Failed to send cancel event. rc=%d\n", rsp_rc);
2306 /* If failure is received, the host adapter is most likely going
2307 through reset, return success so the caller will wait for the command
2308 being cancelled to get returned */
2309 return 0;
2310 }
2311
2312 sdev_printk(KERN_INFO, sdev, "Cancelling outstanding commands.\n");
2313
2314 wait_for_completion(&evt->comp);
2315 status = be16_to_cpu(rsp.mad_common.status);
2316 spin_lock_irqsave(vhost->host->host_lock, flags);
2317 ibmvfc_free_event(evt);
2318 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2319
2320 if (status != IBMVFC_MAD_SUCCESS) {
2321 sdev_printk(KERN_WARNING, sdev, "Cancel failed with rc=%x\n", status);
2322 switch (status) {
2323 case IBMVFC_MAD_DRIVER_FAILED:
2324 case IBMVFC_MAD_CRQ_ERROR:
2325 /* Host adapter most likely going through reset, return success to
2326 the caller will wait for the command being cancelled to get returned */
2327 return 0;
2328 default:
2329 return -EIO;
2330 };
2331 }
2332
2333 sdev_printk(KERN_INFO, sdev, "Successfully cancelled outstanding commands\n");
2334 return 0;
2335 }
2336
2337 /**
2338 * ibmvfc_match_key - Match function for specified cancel key
2339 * @evt: ibmvfc event struct
2340 * @key: cancel key to match
2341 *
2342 * Returns:
2343 * 1 if event matches key / 0 if event does not match key
2344 **/
2345 static int ibmvfc_match_key(struct ibmvfc_event *evt, void *key)
2346 {
2347 unsigned long cancel_key = (unsigned long)key;
2348
2349 if (evt->crq.format == IBMVFC_CMD_FORMAT &&
2350 be32_to_cpu(evt->iu.cmd.cancel_key) == cancel_key)
2351 return 1;
2352 return 0;
2353 }
2354
2355 /**
2356 * ibmvfc_match_evt - Match function for specified event
2357 * @evt: ibmvfc event struct
2358 * @match: event to match
2359 *
2360 * Returns:
2361 * 1 if event matches key / 0 if event does not match key
2362 **/
2363 static int ibmvfc_match_evt(struct ibmvfc_event *evt, void *match)
2364 {
2365 if (evt == match)
2366 return 1;
2367 return 0;
2368 }
2369
2370 /**
2371 * ibmvfc_abort_task_set - Abort outstanding commands to the device
2372 * @sdev: scsi device to abort commands
2373 *
2374 * This sends an Abort Task Set to the VIOS for the specified device. This does
2375 * NOT send any cancel to the VIOS. That must be done separately.
2376 *
2377 * Returns:
2378 * 0 on success / other on failure
2379 **/
2380 static int ibmvfc_abort_task_set(struct scsi_device *sdev)
2381 {
2382 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2383 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2384 struct ibmvfc_cmd *tmf;
2385 struct ibmvfc_event *evt, *found_evt;
2386 union ibmvfc_iu rsp_iu;
2387 struct ibmvfc_fcp_cmd_iu *iu;
2388 struct ibmvfc_fcp_rsp *fc_rsp = ibmvfc_get_fcp_rsp(vhost, &rsp_iu.cmd);
2389 int rc, rsp_rc = -EBUSY;
2390 unsigned long flags, timeout = IBMVFC_ABORT_TIMEOUT;
2391 int rsp_code = 0;
2392
2393 spin_lock_irqsave(vhost->host->host_lock, flags);
2394 found_evt = NULL;
2395 list_for_each_entry(evt, &vhost->sent, queue) {
2396 if (evt->cmnd && evt->cmnd->device == sdev) {
2397 found_evt = evt;
2398 break;
2399 }
2400 }
2401
2402 if (!found_evt) {
2403 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
2404 sdev_printk(KERN_INFO, sdev, "No events found to abort\n");
2405 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2406 return 0;
2407 }
2408
2409 if (vhost->state == IBMVFC_ACTIVE) {
2410 evt = ibmvfc_get_event(vhost);
2411 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
2412 tmf = ibmvfc_init_vfc_cmd(evt, sdev);
2413 iu = ibmvfc_get_fcp_iu(vhost, tmf);
2414
2415 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN))
2416 tmf->target_wwpn = cpu_to_be64(rport->port_name);
2417 iu->tmf_flags = IBMVFC_ABORT_TASK_SET;
2418 tmf->flags = cpu_to_be16((IBMVFC_NO_MEM_DESC | IBMVFC_TMF));
2419 evt->sync_iu = &rsp_iu;
2420
2421 tmf->correlation = cpu_to_be64(evt);
2422
2423 init_completion(&evt->comp);
2424 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
2425 }
2426
2427 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2428
2429 if (rsp_rc != 0) {
2430 sdev_printk(KERN_ERR, sdev, "Failed to send abort. rc=%d\n", rsp_rc);
2431 return -EIO;
2432 }
2433
2434 sdev_printk(KERN_INFO, sdev, "Aborting outstanding commands\n");
2435 timeout = wait_for_completion_timeout(&evt->comp, timeout);
2436
2437 if (!timeout) {
2438 rc = ibmvfc_cancel_all(sdev, 0);
2439 if (!rc) {
2440 rc = ibmvfc_wait_for_ops(vhost, sdev->hostdata, ibmvfc_match_key);
2441 if (rc == SUCCESS)
2442 rc = 0;
2443 }
2444
2445 if (rc) {
2446 sdev_printk(KERN_INFO, sdev, "Cancel failed, resetting host\n");
2447 ibmvfc_reset_host(vhost);
2448 rsp_rc = -EIO;
2449 rc = ibmvfc_wait_for_ops(vhost, sdev->hostdata, ibmvfc_match_key);
2450
2451 if (rc == SUCCESS)
2452 rsp_rc = 0;
2453
2454 rc = ibmvfc_wait_for_ops(vhost, evt, ibmvfc_match_evt);
2455 if (rc != SUCCESS) {
2456 spin_lock_irqsave(vhost->host->host_lock, flags);
2457 ibmvfc_hard_reset_host(vhost);
2458 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2459 rsp_rc = 0;
2460 }
2461
2462 goto out;
2463 }
2464 }
2465
2466 if (rsp_iu.cmd.status)
2467 rsp_code = ibmvfc_get_err_result(vhost, &rsp_iu.cmd);
2468
2469 if (rsp_code) {
2470 if (fc_rsp->flags & FCP_RSP_LEN_VALID)
2471 rsp_code = fc_rsp->data.info.rsp_code;
2472
2473 sdev_printk(KERN_ERR, sdev, "Abort failed: %s (%x:%x) "
2474 "flags: %x fcp_rsp: %x, scsi_status: %x\n",
2475 ibmvfc_get_cmd_error(be16_to_cpu(rsp_iu.cmd.status), be16_to_cpu(rsp_iu.cmd.error)),
2476 be16_to_cpu(rsp_iu.cmd.status), be16_to_cpu(rsp_iu.cmd.error), fc_rsp->flags, rsp_code,
2477 fc_rsp->scsi_status);
2478 rsp_rc = -EIO;
2479 } else
2480 sdev_printk(KERN_INFO, sdev, "Abort successful\n");
2481
2482 out:
2483 spin_lock_irqsave(vhost->host->host_lock, flags);
2484 ibmvfc_free_event(evt);
2485 spin_unlock_irqrestore(vhost->host->host_lock, flags);
2486 return rsp_rc;
2487 }
2488
2489 /**
2490 * ibmvfc_eh_abort_handler - Abort a command
2491 * @cmd: scsi command to abort
2492 *
2493 * Returns:
2494 * SUCCESS / FAST_IO_FAIL / FAILED
2495 **/
2496 static int ibmvfc_eh_abort_handler(struct scsi_cmnd *cmd)
2497 {
2498 struct scsi_device *sdev = cmd->device;
2499 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2500 int cancel_rc, block_rc;
2501 int rc = FAILED;
2502
2503 ENTER;
2504 block_rc = fc_block_scsi_eh(cmd);
2505 ibmvfc_wait_while_resetting(vhost);
2506 if (block_rc != FAST_IO_FAIL) {
2507 cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
2508 ibmvfc_abort_task_set(sdev);
2509 } else
2510 cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
2511
2512 if (!cancel_rc)
2513 rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
2514
2515 if (block_rc == FAST_IO_FAIL && rc != FAILED)
2516 rc = FAST_IO_FAIL;
2517
2518 LEAVE;
2519 return rc;
2520 }
2521
2522 /**
2523 * ibmvfc_eh_device_reset_handler - Reset a single LUN
2524 * @cmd: scsi command struct
2525 *
2526 * Returns:
2527 * SUCCESS / FAST_IO_FAIL / FAILED
2528 **/
2529 static int ibmvfc_eh_device_reset_handler(struct scsi_cmnd *cmd)
2530 {
2531 struct scsi_device *sdev = cmd->device;
2532 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2533 int cancel_rc, block_rc, reset_rc = 0;
2534 int rc = FAILED;
2535
2536 ENTER;
2537 block_rc = fc_block_scsi_eh(cmd);
2538 ibmvfc_wait_while_resetting(vhost);
2539 if (block_rc != FAST_IO_FAIL) {
2540 cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_LUN_RESET);
2541 reset_rc = ibmvfc_reset_device(sdev, IBMVFC_LUN_RESET, "LUN");
2542 } else
2543 cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
2544
2545 if (!cancel_rc && !reset_rc)
2546 rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
2547
2548 if (block_rc == FAST_IO_FAIL && rc != FAILED)
2549 rc = FAST_IO_FAIL;
2550
2551 LEAVE;
2552 return rc;
2553 }
2554
2555 /**
2556 * ibmvfc_dev_cancel_all_noreset - Device iterated cancel all function
2557 * @sdev: scsi device struct
2558 * @data: return code
2559 *
2560 **/
2561 static void ibmvfc_dev_cancel_all_noreset(struct scsi_device *sdev, void *data)
2562 {
2563 unsigned long *rc = data;
2564 *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
2565 }
2566
2567 /**
2568 * ibmvfc_dev_cancel_all_reset - Device iterated cancel all function
2569 * @sdev: scsi device struct
2570 * @data: return code
2571 *
2572 **/
2573 static void ibmvfc_dev_cancel_all_reset(struct scsi_device *sdev, void *data)
2574 {
2575 unsigned long *rc = data;
2576 *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_TGT_RESET);
2577 }
2578
2579 /**
2580 * ibmvfc_eh_target_reset_handler - Reset the target
2581 * @cmd: scsi command struct
2582 *
2583 * Returns:
2584 * SUCCESS / FAST_IO_FAIL / FAILED
2585 **/
2586 static int ibmvfc_eh_target_reset_handler(struct scsi_cmnd *cmd)
2587 {
2588 struct scsi_device *sdev = cmd->device;
2589 struct ibmvfc_host *vhost = shost_priv(sdev->host);
2590 struct scsi_target *starget = scsi_target(sdev);
2591 int block_rc;
2592 int reset_rc = 0;
2593 int rc = FAILED;
2594 unsigned long cancel_rc = 0;
2595
2596 ENTER;
2597 block_rc = fc_block_scsi_eh(cmd);
2598 ibmvfc_wait_while_resetting(vhost);
2599 if (block_rc != FAST_IO_FAIL) {
2600 starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_reset);
2601 reset_rc = ibmvfc_reset_device(sdev, IBMVFC_TARGET_RESET, "target");
2602 } else
2603 starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_noreset);
2604
2605 if (!cancel_rc && !reset_rc)
2606 rc = ibmvfc_wait_for_ops(vhost, starget, ibmvfc_match_target);
2607
2608 if (block_rc == FAST_IO_FAIL && rc != FAILED)
2609 rc = FAST_IO_FAIL;
2610
2611 LEAVE;
2612 return rc;
2613 }
2614
2615 /**
2616 * ibmvfc_eh_host_reset_handler - Reset the connection to the server
2617 * @cmd: struct scsi_cmnd having problems
2618 *
2619 **/
2620 static int ibmvfc_eh_host_reset_handler(struct scsi_cmnd *cmd)
2621 {
2622 int rc;
2623 struct ibmvfc_host *vhost = shost_priv(cmd->device->host);
2624
2625 dev_err(vhost->dev, "Resetting connection due to error recovery\n");
2626 rc = ibmvfc_issue_fc_host_lip(vhost->host);
2627
2628 return rc ? FAILED : SUCCESS;
2629 }
2630
2631 /**
2632 * ibmvfc_terminate_rport_io - Terminate all pending I/O to the rport.
2633 * @rport: rport struct
2634 *
2635 * Return value:
2636 * none
2637 **/
2638 static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
2639 {
2640 struct Scsi_Host *shost = rport_to_shost(rport);
2641 struct ibmvfc_host *vhost = shost_priv(shost);
2642 struct fc_rport *dev_rport;
2643 struct scsi_device *sdev;
2644 struct ibmvfc_target *tgt;
2645 unsigned long rc, flags;
2646 unsigned int found;
2647
2648 ENTER;
2649 shost_for_each_device(sdev, shost) {
2650 dev_rport = starget_to_rport(scsi_target(sdev));
2651 if (dev_rport != rport)
2652 continue;
2653 ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
2654 }
2655
2656 rc = ibmvfc_wait_for_ops(vhost, rport, ibmvfc_match_rport);
2657
2658 if (rc == FAILED)
2659 ibmvfc_issue_fc_host_lip(shost);
2660
2661 spin_lock_irqsave(shost->host_lock, flags);
2662 found = 0;
2663 list_for_each_entry(tgt, &vhost->targets, queue) {
2664 if (tgt->scsi_id == rport->port_id) {
2665 found++;
2666 break;
2667 }
2668 }
2669
2670 if (found && tgt->action == IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT) {
2671 /*
2672 * If we get here, that means we previously attempted to send
2673 * an implicit logout to the target but it failed, most likely
2674 * due to I/O being pending, so we need to send it again
2675 */
2676 ibmvfc_del_tgt(tgt);
2677 ibmvfc_reinit_host(vhost);
2678 }
2679
2680 spin_unlock_irqrestore(shost->host_lock, flags);
2681 LEAVE;
2682 }
2683
2684 static const struct ibmvfc_async_desc ae_desc [] = {
2685 { "PLOGI", IBMVFC_AE_ELS_PLOGI, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
2686 { "LOGO", IBMVFC_AE_ELS_LOGO, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
2687 { "PRLO", IBMVFC_AE_ELS_PRLO, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
2688 { "N-Port SCN", IBMVFC_AE_SCN_NPORT, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
2689 { "Group SCN", IBMVFC_AE_SCN_GROUP, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
2690 { "Domain SCN", IBMVFC_AE_SCN_DOMAIN, IBMVFC_DEFAULT_LOG_LEVEL },
2691 { "Fabric SCN", IBMVFC_AE_SCN_FABRIC, IBMVFC_DEFAULT_LOG_LEVEL },
2692 { "Link Up", IBMVFC_AE_LINK_UP, IBMVFC_DEFAULT_LOG_LEVEL },
2693 { "Link Down", IBMVFC_AE_LINK_DOWN, IBMVFC_DEFAULT_LOG_LEVEL },
2694 { "Link Dead", IBMVFC_AE_LINK_DEAD, IBMVFC_DEFAULT_LOG_LEVEL },
2695 { "Halt", IBMVFC_AE_HALT, IBMVFC_DEFAULT_LOG_LEVEL },
2696 { "Resume", IBMVFC_AE_RESUME, IBMVFC_DEFAULT_LOG_LEVEL },
2697 { "Adapter Failed", IBMVFC_AE_ADAPTER_FAILED, IBMVFC_DEFAULT_LOG_LEVEL },
2698 };
2699
2700 static const struct ibmvfc_async_desc unknown_ae = {
2701 "Unknown async", 0, IBMVFC_DEFAULT_LOG_LEVEL
2702 };
2703
2704 /**
2705 * ibmvfc_get_ae_desc - Get text description for async event
2706 * @ae: async event
2707 *
2708 **/
2709 static const struct ibmvfc_async_desc *ibmvfc_get_ae_desc(u64 ae)
2710 {
2711 int i;
2712
2713 for (i = 0; i < ARRAY_SIZE(ae_desc); i++)
2714 if (ae_desc[i].ae == ae)
2715 return &ae_desc[i];
2716
2717 return &unknown_ae;
2718 }
2719
2720 static const struct {
2721 enum ibmvfc_ae_link_state state;
2722 const char *desc;
2723 } link_desc [] = {
2724 { IBMVFC_AE_LS_LINK_UP, " link up" },
2725 { IBMVFC_AE_LS_LINK_BOUNCED, " link bounced" },
2726 { IBMVFC_AE_LS_LINK_DOWN, " link down" },
2727 { IBMVFC_AE_LS_LINK_DEAD, " link dead" },
2728 };
2729
2730 /**
2731 * ibmvfc_get_link_state - Get text description for link state
2732 * @state: link state
2733 *
2734 **/
2735 static const char *ibmvfc_get_link_state(enum ibmvfc_ae_link_state state)
2736 {
2737 int i;
2738
2739 for (i = 0; i < ARRAY_SIZE(link_desc); i++)
2740 if (link_desc[i].state == state)
2741 return link_desc[i].desc;
2742
2743 return "";
2744 }
2745
2746 /**
2747 * ibmvfc_handle_async - Handle an async event from the adapter
2748 * @crq: crq to process
2749 * @vhost: ibmvfc host struct
2750 *
2751 **/
2752 static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
2753 struct ibmvfc_host *vhost)
2754 {
2755 const struct ibmvfc_async_desc *desc = ibmvfc_get_ae_desc(be64_to_cpu(crq->event));
2756 struct ibmvfc_target *tgt;
2757
2758 ibmvfc_log(vhost, desc->log_level, "%s event received. scsi_id: %llx, wwpn: %llx,"
2759 " node_name: %llx%s\n", desc->desc, be64_to_cpu(crq->scsi_id),
2760 be64_to_cpu(crq->wwpn), be64_to_cpu(crq->node_name),
2761 ibmvfc_get_link_state(crq->link_state));
2762
2763 switch (be64_to_cpu(crq->event)) {
2764 case IBMVFC_AE_RESUME:
2765 switch (crq->link_state) {
2766 case IBMVFC_AE_LS_LINK_DOWN:
2767 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2768 break;
2769 case IBMVFC_AE_LS_LINK_DEAD:
2770 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
2771 break;
2772 case IBMVFC_AE_LS_LINK_UP:
2773 case IBMVFC_AE_LS_LINK_BOUNCED:
2774 default:
2775 vhost->events_to_log |= IBMVFC_AE_LINKUP;
2776 vhost->delay_init = 1;
2777 __ibmvfc_reset_host(vhost);
2778 break;
2779 }
2780
2781 break;
2782 case IBMVFC_AE_LINK_UP:
2783 vhost->events_to_log |= IBMVFC_AE_LINKUP;
2784 vhost->delay_init = 1;
2785 __ibmvfc_reset_host(vhost);
2786 break;
2787 case IBMVFC_AE_SCN_FABRIC:
2788 case IBMVFC_AE_SCN_DOMAIN:
2789 vhost->events_to_log |= IBMVFC_AE_RSCN;
2790 if (vhost->state < IBMVFC_HALTED) {
2791 vhost->delay_init = 1;
2792 __ibmvfc_reset_host(vhost);
2793 }
2794 break;
2795 case IBMVFC_AE_SCN_NPORT:
2796 case IBMVFC_AE_SCN_GROUP:
2797 vhost->events_to_log |= IBMVFC_AE_RSCN;
2798 ibmvfc_reinit_host(vhost);
2799 break;
2800 case IBMVFC_AE_ELS_LOGO:
2801 case IBMVFC_AE_ELS_PRLO:
2802 case IBMVFC_AE_ELS_PLOGI:
2803 list_for_each_entry(tgt, &vhost->targets, queue) {
2804 if (!crq->scsi_id && !crq->wwpn && !crq->node_name)
2805 break;
2806 if (crq->scsi_id && cpu_to_be64(tgt->scsi_id) != crq->scsi_id)
2807 continue;
2808 if (crq->wwpn && cpu_to_be64(tgt->ids.port_name) != crq->wwpn)
2809 continue;
2810 if (crq->node_name && cpu_to_be64(tgt->ids.node_name) != crq->node_name)
2811 continue;
2812 if (tgt->need_login && be64_to_cpu(crq->event) == IBMVFC_AE_ELS_LOGO)
2813 tgt->logo_rcvd = 1;
2814 if (!tgt->need_login || be64_to_cpu(crq->event) == IBMVFC_AE_ELS_PLOGI) {
2815 ibmvfc_del_tgt(tgt);
2816 ibmvfc_reinit_host(vhost);
2817 }
2818 }
2819 break;
2820 case IBMVFC_AE_LINK_DOWN:
2821 case IBMVFC_AE_ADAPTER_FAILED:
2822 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2823 break;
2824 case IBMVFC_AE_LINK_DEAD:
2825 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
2826 break;
2827 case IBMVFC_AE_HALT:
2828 ibmvfc_link_down(vhost, IBMVFC_HALTED);
2829 break;
2830 default:
2831 dev_err(vhost->dev, "Unknown async event received: %lld\n", crq->event);
2832 break;
2833 }
2834 }
2835
2836 /**
2837 * ibmvfc_handle_crq - Handles and frees received events in the CRQ
2838 * @crq: Command/Response queue
2839 * @vhost: ibmvfc host struct
2840 *
2841 **/
2842 static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
2843 {
2844 long rc;
2845 struct ibmvfc_event *evt = (struct ibmvfc_event *)be64_to_cpu(crq->ioba);
2846
2847 switch (crq->valid) {
2848 case IBMVFC_CRQ_INIT_RSP:
2849 switch (crq->format) {
2850 case IBMVFC_CRQ_INIT:
2851 dev_info(vhost->dev, "Partner initialized\n");
2852 /* Send back a response */
2853 rc = ibmvfc_send_crq_init_complete(vhost);
2854 if (rc == 0)
2855 ibmvfc_init_host(vhost);
2856 else
2857 dev_err(vhost->dev, "Unable to send init rsp. rc=%ld\n", rc);
2858 break;
2859 case IBMVFC_CRQ_INIT_COMPLETE:
2860 dev_info(vhost->dev, "Partner initialization complete\n");
2861 ibmvfc_init_host(vhost);
2862 break;
2863 default:
2864 dev_err(vhost->dev, "Unknown crq message type: %d\n", crq->format);
2865 }
2866 return;
2867 case IBMVFC_CRQ_XPORT_EVENT:
2868 vhost->state = IBMVFC_NO_CRQ;
2869 vhost->logged_in = 0;
2870 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
2871 if (crq->format == IBMVFC_PARTITION_MIGRATED) {
2872 /* We need to re-setup the interpartition connection */
2873 dev_info(vhost->dev, "Partition migrated, Re-enabling adapter\n");
2874 vhost->client_migrated = 1;
2875 ibmvfc_purge_requests(vhost, DID_REQUEUE);
2876 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2877 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_REENABLE);
2878 } else if (crq->format == IBMVFC_PARTNER_FAILED || crq->format == IBMVFC_PARTNER_DEREGISTER) {
2879 dev_err(vhost->dev, "Host partner adapter deregistered or failed (rc=%d)\n", crq->format);
2880 ibmvfc_purge_requests(vhost, DID_ERROR);
2881 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2882 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_RESET);
2883 } else {
2884 dev_err(vhost->dev, "Received unknown transport event from partner (rc=%d)\n", crq->format);
2885 }
2886 return;
2887 case IBMVFC_CRQ_CMD_RSP:
2888 break;
2889 default:
2890 dev_err(vhost->dev, "Got an invalid message type 0x%02x\n", crq->valid);
2891 return;
2892 }
2893
2894 if (crq->format == IBMVFC_ASYNC_EVENT)
2895 return;
2896
2897 /* The only kind of payload CRQs we should get are responses to
2898 * things we send. Make sure this response is to something we
2899 * actually sent
2900 */
2901 if (unlikely(!ibmvfc_valid_event(&vhost->pool, evt))) {
2902 dev_err(vhost->dev, "Returned correlation_token 0x%08llx is invalid!\n",
2903 crq->ioba);
2904 return;
2905 }
2906
2907 if (unlikely(atomic_read(&evt->free))) {
2908 dev_err(vhost->dev, "Received duplicate correlation_token 0x%08llx!\n",
2909 crq->ioba);
2910 return;
2911 }
2912
2913 del_timer(&evt->timer);
2914 list_del(&evt->queue);
2915 ibmvfc_trc_end(evt);
2916 evt->done(evt);
2917 }
2918
2919 /**
2920 * ibmvfc_scan_finished - Check if the device scan is done.
2921 * @shost: scsi host struct
2922 * @time: current elapsed time
2923 *
2924 * Returns:
2925 * 0 if scan is not done / 1 if scan is done
2926 **/
2927 static int ibmvfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
2928 {
2929 unsigned long flags;
2930 struct ibmvfc_host *vhost = shost_priv(shost);
2931 int done = 0;
2932
2933 spin_lock_irqsave(shost->host_lock, flags);
2934 if (time >= (init_timeout * HZ)) {
2935 dev_info(vhost->dev, "Scan taking longer than %d seconds, "
2936 "continuing initialization\n", init_timeout);
2937 done = 1;
2938 }
2939
2940 if (vhost->scan_complete)
2941 done = 1;
2942 spin_unlock_irqrestore(shost->host_lock, flags);
2943 return done;
2944 }
2945
2946 /**
2947 * ibmvfc_slave_alloc - Setup the device's task set value
2948 * @sdev: struct scsi_device device to configure
2949 *
2950 * Set the device's task set value so that error handling works as
2951 * expected.
2952 *
2953 * Returns:
2954 * 0 on success / -ENXIO if device does not exist
2955 **/
2956 static int ibmvfc_slave_alloc(struct scsi_device *sdev)
2957 {
2958 struct Scsi_Host *shost = sdev->host;
2959 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2960 struct ibmvfc_host *vhost = shost_priv(shost);
2961 unsigned long flags = 0;
2962
2963 if (!rport || fc_remote_port_chkready(rport))
2964 return -ENXIO;
2965
2966 spin_lock_irqsave(shost->host_lock, flags);
2967 sdev->hostdata = (void *)(unsigned long)vhost->task_set++;
2968 spin_unlock_irqrestore(shost->host_lock, flags);
2969 return 0;
2970 }
2971
2972 /**
2973 * ibmvfc_target_alloc - Setup the target's task set value
2974 * @starget: struct scsi_target
2975 *
2976 * Set the target's task set value so that error handling works as
2977 * expected.
2978 *
2979 * Returns:
2980 * 0 on success / -ENXIO if device does not exist
2981 **/
2982 static int ibmvfc_target_alloc(struct scsi_target *starget)
2983 {
2984 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2985 struct ibmvfc_host *vhost = shost_priv(shost);
2986 unsigned long flags = 0;
2987
2988 spin_lock_irqsave(shost->host_lock, flags);
2989 starget->hostdata = (void *)(unsigned long)vhost->task_set++;
2990 spin_unlock_irqrestore(shost->host_lock, flags);
2991 return 0;
2992 }
2993
2994 /**
2995 * ibmvfc_slave_configure - Configure the device
2996 * @sdev: struct scsi_device device to configure
2997 *
2998 * Enable allow_restart for a device if it is a disk. Adjust the
2999 * queue_depth here also.
3000 *
3001 * Returns:
3002 * 0
3003 **/
3004 static int ibmvfc_slave_configure(struct scsi_device *sdev)
3005 {
3006 struct Scsi_Host *shost = sdev->host;
3007 unsigned long flags = 0;
3008
3009 spin_lock_irqsave(shost->host_lock, flags);
3010 if (sdev->type == TYPE_DISK)
3011 sdev->allow_restart = 1;
3012 spin_unlock_irqrestore(shost->host_lock, flags);
3013 return 0;
3014 }
3015
3016 /**
3017 * ibmvfc_change_queue_depth - Change the device's queue depth
3018 * @sdev: scsi device struct
3019 * @qdepth: depth to set
3020 * @reason: calling context
3021 *
3022 * Return value:
3023 * actual depth set
3024 **/
3025 static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth)
3026 {
3027 if (qdepth > IBMVFC_MAX_CMDS_PER_LUN)
3028 qdepth = IBMVFC_MAX_CMDS_PER_LUN;
3029
3030 return scsi_change_queue_depth(sdev, qdepth);
3031 }
3032
3033 static ssize_t ibmvfc_show_host_partition_name(struct device *dev,
3034 struct device_attribute *attr, char *buf)
3035 {
3036 struct Scsi_Host *shost = class_to_shost(dev);
3037 struct ibmvfc_host *vhost = shost_priv(shost);
3038
3039 return snprintf(buf, PAGE_SIZE, "%s\n",
3040 vhost->login_buf->resp.partition_name);
3041 }
3042
3043 static ssize_t ibmvfc_show_host_device_name(struct device *dev,
3044 struct device_attribute *attr, char *buf)
3045 {
3046 struct Scsi_Host *shost = class_to_shost(dev);
3047 struct ibmvfc_host *vhost = shost_priv(shost);
3048
3049 return snprintf(buf, PAGE_SIZE, "%s\n",
3050 vhost->login_buf->resp.device_name);
3051 }
3052
3053 static ssize_t ibmvfc_show_host_loc_code(struct device *dev,
3054 struct device_attribute *attr, char *buf)
3055 {
3056 struct Scsi_Host *shost = class_to_shost(dev);
3057 struct ibmvfc_host *vhost = shost_priv(shost);
3058
3059 return snprintf(buf, PAGE_SIZE, "%s\n",
3060 vhost->login_buf->resp.port_loc_code);
3061 }
3062
3063 static ssize_t ibmvfc_show_host_drc_name(struct device *dev,
3064 struct device_attribute *attr, char *buf)
3065 {
3066 struct Scsi_Host *shost = class_to_shost(dev);
3067 struct ibmvfc_host *vhost = shost_priv(shost);
3068
3069 return snprintf(buf, PAGE_SIZE, "%s\n",
3070 vhost->login_buf->resp.drc_name);
3071 }
3072
3073 static ssize_t ibmvfc_show_host_npiv_version(struct device *dev,
3074 struct device_attribute *attr, char *buf)
3075 {
3076 struct Scsi_Host *shost = class_to_shost(dev);
3077 struct ibmvfc_host *vhost = shost_priv(shost);
3078 return snprintf(buf, PAGE_SIZE, "%d\n", be32_to_cpu(vhost->login_buf->resp.version));
3079 }
3080
3081 static ssize_t ibmvfc_show_host_capabilities(struct device *dev,
3082 struct device_attribute *attr, char *buf)
3083 {
3084 struct Scsi_Host *shost = class_to_shost(dev);
3085 struct ibmvfc_host *vhost = shost_priv(shost);
3086 return snprintf(buf, PAGE_SIZE, "%llx\n", be64_to_cpu(vhost->login_buf->resp.capabilities));
3087 }
3088
3089 /**
3090 * ibmvfc_show_log_level - Show the adapter's error logging level
3091 * @dev: class device struct
3092 * @buf: buffer
3093 *
3094 * Return value:
3095 * number of bytes printed to buffer
3096 **/
3097 static ssize_t ibmvfc_show_log_level(struct device *dev,
3098 struct device_attribute *attr, char *buf)
3099 {
3100 struct Scsi_Host *shost = class_to_shost(dev);
3101 struct ibmvfc_host *vhost = shost_priv(shost);
3102 unsigned long flags = 0;
3103 int len;
3104
3105 spin_lock_irqsave(shost->host_lock, flags);
3106 len = snprintf(buf, PAGE_SIZE, "%d\n", vhost->log_level);
3107 spin_unlock_irqrestore(shost->host_lock, flags);
3108 return len;
3109 }
3110
3111 /**
3112 * ibmvfc_store_log_level - Change the adapter's error logging level
3113 * @dev: class device struct
3114 * @buf: buffer
3115 *
3116 * Return value:
3117 * number of bytes printed to buffer
3118 **/
3119 static ssize_t ibmvfc_store_log_level(struct device *dev,
3120 struct device_attribute *attr,
3121 const char *buf, size_t count)
3122 {
3123 struct Scsi_Host *shost = class_to_shost(dev);
3124 struct ibmvfc_host *vhost = shost_priv(shost);
3125 unsigned long flags = 0;
3126
3127 spin_lock_irqsave(shost->host_lock, flags);
3128 vhost->log_level = simple_strtoul(buf, NULL, 10);
3129 spin_unlock_irqrestore(shost->host_lock, flags);
3130 return strlen(buf);
3131 }
3132
3133 static DEVICE_ATTR(partition_name, S_IRUGO, ibmvfc_show_host_partition_name, NULL);
3134 static DEVICE_ATTR(device_name, S_IRUGO, ibmvfc_show_host_device_name, NULL);
3135 static DEVICE_ATTR(port_loc_code, S_IRUGO, ibmvfc_show_host_loc_code, NULL);
3136 static DEVICE_ATTR(drc_name, S_IRUGO, ibmvfc_show_host_drc_name, NULL);
3137 static DEVICE_ATTR(npiv_version, S_IRUGO, ibmvfc_show_host_npiv_version, NULL);
3138 static DEVICE_ATTR(capabilities, S_IRUGO, ibmvfc_show_host_capabilities, NULL);
3139 static DEVICE_ATTR(log_level, S_IRUGO | S_IWUSR,
3140 ibmvfc_show_log_level, ibmvfc_store_log_level);
3141
3142 #ifdef CONFIG_SCSI_IBMVFC_TRACE
3143 /**
3144 * ibmvfc_read_trace - Dump the adapter trace
3145 * @filp: open sysfs file
3146 * @kobj: kobject struct
3147 * @bin_attr: bin_attribute struct
3148 * @buf: buffer
3149 * @off: offset
3150 * @count: buffer size
3151 *
3152 * Return value:
3153 * number of bytes printed to buffer
3154 **/
3155 static ssize_t ibmvfc_read_trace(struct file *filp, struct kobject *kobj,
3156 struct bin_attribute *bin_attr,
3157 char *buf, loff_t off, size_t count)
3158 {
3159 struct device *dev = container_of(kobj, struct device, kobj);
3160 struct Scsi_Host *shost = class_to_shost(dev);
3161 struct ibmvfc_host *vhost = shost_priv(shost);
3162 unsigned long flags = 0;
3163 int size = IBMVFC_TRACE_SIZE;
3164 char *src = (char *)vhost->trace;
3165
3166 if (off > size)
3167 return 0;
3168 if (off + count > size) {
3169 size -= off;
3170 count = size;
3171 }
3172
3173 spin_lock_irqsave(shost->host_lock, flags);
3174 memcpy(buf, &src[off], count);
3175 spin_unlock_irqrestore(shost->host_lock, flags);
3176 return count;
3177 }
3178
3179 static struct bin_attribute ibmvfc_trace_attr = {
3180 .attr = {
3181 .name = "trace",
3182 .mode = S_IRUGO,
3183 },
3184 .size = 0,
3185 .read = ibmvfc_read_trace,
3186 };
3187 #endif
3188
3189 static struct device_attribute *ibmvfc_attrs[] = {
3190 &dev_attr_partition_name,
3191 &dev_attr_device_name,
3192 &dev_attr_port_loc_code,
3193 &dev_attr_drc_name,
3194 &dev_attr_npiv_version,
3195 &dev_attr_capabilities,
3196 &dev_attr_log_level,
3197 NULL
3198 };
3199
3200 static struct scsi_host_template driver_template = {
3201 .module = THIS_MODULE,
3202 .name = "IBM POWER Virtual FC Adapter",
3203 .proc_name = IBMVFC_NAME,
3204 .queuecommand = ibmvfc_queuecommand,
3205 .eh_timed_out = fc_eh_timed_out,
3206 .eh_abort_handler = ibmvfc_eh_abort_handler,
3207 .eh_device_reset_handler = ibmvfc_eh_device_reset_handler,
3208 .eh_target_reset_handler = ibmvfc_eh_target_reset_handler,
3209 .eh_host_reset_handler = ibmvfc_eh_host_reset_handler,
3210 .slave_alloc = ibmvfc_slave_alloc,
3211 .slave_configure = ibmvfc_slave_configure,
3212 .target_alloc = ibmvfc_target_alloc,
3213 .scan_finished = ibmvfc_scan_finished,
3214 .change_queue_depth = ibmvfc_change_queue_depth,
3215 .cmd_per_lun = 16,
3216 .can_queue = IBMVFC_MAX_REQUESTS_DEFAULT,
3217 .this_id = -1,
3218 .sg_tablesize = SG_ALL,
3219 .max_sectors = IBMVFC_MAX_SECTORS,
3220 .shost_attrs = ibmvfc_attrs,
3221 .track_queue_depth = 1,
3222 };
3223
3224 /**
3225 * ibmvfc_next_async_crq - Returns the next entry in async queue
3226 * @vhost: ibmvfc host struct
3227 *
3228 * Returns:
3229 * Pointer to next entry in queue / NULL if empty
3230 **/
3231 static struct ibmvfc_async_crq *ibmvfc_next_async_crq(struct ibmvfc_host *vhost)
3232 {
3233 struct ibmvfc_async_crq_queue *async_crq = &vhost->async_crq;
3234 struct ibmvfc_async_crq *crq;
3235
3236 crq = &async_crq->msgs[async_crq->cur];
3237 if (crq->valid & 0x80) {
3238 if (++async_crq->cur == async_crq->size)
3239 async_crq->cur = 0;
3240 rmb();
3241 } else
3242 crq = NULL;
3243
3244 return crq;
3245 }
3246
3247 /**
3248 * ibmvfc_next_crq - Returns the next entry in message queue
3249 * @vhost: ibmvfc host struct
3250 *
3251 * Returns:
3252 * Pointer to next entry in queue / NULL if empty
3253 **/
3254 static struct ibmvfc_crq *ibmvfc_next_crq(struct ibmvfc_host *vhost)
3255 {
3256 struct ibmvfc_crq_queue *queue = &vhost->crq;
3257 struct ibmvfc_crq *crq;
3258
3259 crq = &queue->msgs[queue->cur];
3260 if (crq->valid & 0x80) {
3261 if (++queue->cur == queue->size)
3262 queue->cur = 0;
3263 rmb();
3264 } else
3265 crq = NULL;
3266
3267 return crq;
3268 }
3269
3270 /**
3271 * ibmvfc_interrupt - Interrupt handler
3272 * @irq: number of irq to handle, not used
3273 * @dev_instance: ibmvfc_host that received interrupt
3274 *
3275 * Returns:
3276 * IRQ_HANDLED
3277 **/
3278 static irqreturn_t ibmvfc_interrupt(int irq, void *dev_instance)
3279 {
3280 struct ibmvfc_host *vhost = (struct ibmvfc_host *)dev_instance;
3281 unsigned long flags;
3282
3283 spin_lock_irqsave(vhost->host->host_lock, flags);
3284 vio_disable_interrupts(to_vio_dev(vhost->dev));
3285 tasklet_schedule(&vhost->tasklet);
3286 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3287 return IRQ_HANDLED;
3288 }
3289
3290 /**
3291 * ibmvfc_tasklet - Interrupt handler tasklet
3292 * @data: ibmvfc host struct
3293 *
3294 * Returns:
3295 * Nothing
3296 **/
3297 static void ibmvfc_tasklet(void *data)
3298 {
3299 struct ibmvfc_host *vhost = data;
3300 struct vio_dev *vdev = to_vio_dev(vhost->dev);
3301 struct ibmvfc_crq *crq;
3302 struct ibmvfc_async_crq *async;
3303 unsigned long flags;
3304 int done = 0;
3305
3306 spin_lock_irqsave(vhost->host->host_lock, flags);
3307 while (!done) {
3308 /* Pull all the valid messages off the async CRQ */
3309 while ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
3310 ibmvfc_handle_async(async, vhost);
3311 async->valid = 0;
3312 wmb();
3313 }
3314
3315 /* Pull all the valid messages off the CRQ */
3316 while ((crq = ibmvfc_next_crq(vhost)) != NULL) {
3317 ibmvfc_handle_crq(crq, vhost);
3318 crq->valid = 0;
3319 wmb();
3320 }
3321
3322 vio_enable_interrupts(vdev);
3323 if ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
3324 vio_disable_interrupts(vdev);
3325 ibmvfc_handle_async(async, vhost);
3326 async->valid = 0;
3327 wmb();
3328 } else if ((crq = ibmvfc_next_crq(vhost)) != NULL) {
3329 vio_disable_interrupts(vdev);
3330 ibmvfc_handle_crq(crq, vhost);
3331 crq->valid = 0;
3332 wmb();
3333 } else
3334 done = 1;
3335 }
3336
3337 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3338 }
3339
3340 /**
3341 * ibmvfc_init_tgt - Set the next init job step for the target
3342 * @tgt: ibmvfc target struct
3343 * @job_step: job step to perform
3344 *
3345 **/
3346 static void ibmvfc_init_tgt(struct ibmvfc_target *tgt,
3347 void (*job_step) (struct ibmvfc_target *))
3348 {
3349 if (!ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT))
3350 tgt->job_step = job_step;
3351 wake_up(&tgt->vhost->work_wait_q);
3352 }
3353
3354 /**
3355 * ibmvfc_retry_tgt_init - Attempt to retry a step in target initialization
3356 * @tgt: ibmvfc target struct
3357 * @job_step: initialization job step
3358 *
3359 * Returns: 1 if step will be retried / 0 if not
3360 *
3361 **/
3362 static int ibmvfc_retry_tgt_init(struct ibmvfc_target *tgt,
3363 void (*job_step) (struct ibmvfc_target *))
3364 {
3365 if (++tgt->init_retries > IBMVFC_MAX_TGT_INIT_RETRIES) {
3366 ibmvfc_del_tgt(tgt);
3367 wake_up(&tgt->vhost->work_wait_q);
3368 return 0;
3369 } else
3370 ibmvfc_init_tgt(tgt, job_step);
3371 return 1;
3372 }
3373
3374 /* Defined in FC-LS */
3375 static const struct {
3376 int code;
3377 int retry;
3378 int logged_in;
3379 } prli_rsp [] = {
3380 { 0, 1, 0 },
3381 { 1, 0, 1 },
3382 { 2, 1, 0 },
3383 { 3, 1, 0 },
3384 { 4, 0, 0 },
3385 { 5, 0, 0 },
3386 { 6, 0, 1 },
3387 { 7, 0, 0 },
3388 { 8, 1, 0 },
3389 };
3390
3391 /**
3392 * ibmvfc_get_prli_rsp - Find PRLI response index
3393 * @flags: PRLI response flags
3394 *
3395 **/
3396 static int ibmvfc_get_prli_rsp(u16 flags)
3397 {
3398 int i;
3399 int code = (flags & 0x0f00) >> 8;
3400
3401 for (i = 0; i < ARRAY_SIZE(prli_rsp); i++)
3402 if (prli_rsp[i].code == code)
3403 return i;
3404
3405 return 0;
3406 }
3407
3408 /**
3409 * ibmvfc_tgt_prli_done - Completion handler for Process Login
3410 * @evt: ibmvfc event struct
3411 *
3412 **/
3413 static void ibmvfc_tgt_prli_done(struct ibmvfc_event *evt)
3414 {
3415 struct ibmvfc_target *tgt = evt->tgt;
3416 struct ibmvfc_host *vhost = evt->vhost;
3417 struct ibmvfc_process_login *rsp = &evt->xfer_iu->prli;
3418 struct ibmvfc_prli_svc_parms *parms = &rsp->parms;
3419 u32 status = be16_to_cpu(rsp->common.status);
3420 int index, level = IBMVFC_DEFAULT_LOG_LEVEL;
3421
3422 vhost->discovery_threads--;
3423 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3424 switch (status) {
3425 case IBMVFC_MAD_SUCCESS:
3426 tgt_dbg(tgt, "Process Login succeeded: %X %02X %04X\n",
3427 parms->type, parms->flags, parms->service_parms);
3428
3429 if (parms->type == IBMVFC_SCSI_FCP_TYPE) {
3430 index = ibmvfc_get_prli_rsp(be16_to_cpu(parms->flags));
3431 if (prli_rsp[index].logged_in) {
3432 if (be16_to_cpu(parms->flags) & IBMVFC_PRLI_EST_IMG_PAIR) {
3433 tgt->need_login = 0;
3434 tgt->ids.roles = 0;
3435 if (be32_to_cpu(parms->service_parms) & IBMVFC_PRLI_TARGET_FUNC)
3436 tgt->ids.roles |= FC_PORT_ROLE_FCP_TARGET;
3437 if (be32_to_cpu(parms->service_parms) & IBMVFC_PRLI_INITIATOR_FUNC)
3438 tgt->ids.roles |= FC_PORT_ROLE_FCP_INITIATOR;
3439 tgt->add_rport = 1;
3440 } else
3441 ibmvfc_del_tgt(tgt);
3442 } else if (prli_rsp[index].retry)
3443 ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
3444 else
3445 ibmvfc_del_tgt(tgt);
3446 } else
3447 ibmvfc_del_tgt(tgt);
3448 break;
3449 case IBMVFC_MAD_DRIVER_FAILED:
3450 break;
3451 case IBMVFC_MAD_CRQ_ERROR:
3452 ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
3453 break;
3454 case IBMVFC_MAD_FAILED:
3455 default:
3456 if ((be16_to_cpu(rsp->status) & IBMVFC_VIOS_FAILURE) &&
3457 be16_to_cpu(rsp->error) == IBMVFC_PLOGI_REQUIRED)
3458 level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
3459 else if (tgt->logo_rcvd)
3460 level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
3461 else if (ibmvfc_retry_cmd(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)))
3462 level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
3463 else
3464 ibmvfc_del_tgt(tgt);
3465
3466 tgt_log(tgt, level, "Process Login failed: %s (%x:%x) rc=0x%02X\n",
3467 ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
3468 be16_to_cpu(rsp->status), be16_to_cpu(rsp->error), status);
3469 break;
3470 }
3471
3472 kref_put(&tgt->kref, ibmvfc_release_tgt);
3473 ibmvfc_free_event(evt);
3474 wake_up(&vhost->work_wait_q);
3475 }
3476
3477 /**
3478 * ibmvfc_tgt_send_prli - Send a process login
3479 * @tgt: ibmvfc target struct
3480 *
3481 **/
3482 static void ibmvfc_tgt_send_prli(struct ibmvfc_target *tgt)
3483 {
3484 struct ibmvfc_process_login *prli;
3485 struct ibmvfc_host *vhost = tgt->vhost;
3486 struct ibmvfc_event *evt;
3487
3488 if (vhost->discovery_threads >= disc_threads)
3489 return;
3490
3491 kref_get(&tgt->kref);
3492 evt = ibmvfc_get_event(vhost);
3493 vhost->discovery_threads++;
3494 ibmvfc_init_event(evt, ibmvfc_tgt_prli_done, IBMVFC_MAD_FORMAT);
3495 evt->tgt = tgt;
3496 prli = &evt->iu.prli;
3497 memset(prli, 0, sizeof(*prli));
3498 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN)) {
3499 prli->common.version = cpu_to_be32(2);
3500 prli->target_wwpn = cpu_to_be64(tgt->wwpn);
3501 } else {
3502 prli->common.version = cpu_to_be32(1);
3503 }
3504 prli->common.opcode = cpu_to_be32(IBMVFC_PROCESS_LOGIN);
3505 prli->common.length = cpu_to_be16(sizeof(*prli));
3506 prli->scsi_id = cpu_to_be64(tgt->scsi_id);
3507
3508 prli->parms.type = IBMVFC_SCSI_FCP_TYPE;
3509 prli->parms.flags = cpu_to_be16(IBMVFC_PRLI_EST_IMG_PAIR);
3510 prli->parms.service_parms = cpu_to_be32(IBMVFC_PRLI_INITIATOR_FUNC);
3511 prli->parms.service_parms |= cpu_to_be32(IBMVFC_PRLI_READ_FCP_XFER_RDY_DISABLED);
3512
3513 if (cls3_error)
3514 prli->parms.service_parms |= cpu_to_be32(IBMVFC_PRLI_RETRY);
3515
3516 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
3517 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3518 vhost->discovery_threads--;
3519 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3520 kref_put(&tgt->kref, ibmvfc_release_tgt);
3521 } else
3522 tgt_dbg(tgt, "Sent process login\n");
3523 }
3524
3525 /**
3526 * ibmvfc_tgt_plogi_done - Completion handler for Port Login
3527 * @evt: ibmvfc event struct
3528 *
3529 **/
3530 static void ibmvfc_tgt_plogi_done(struct ibmvfc_event *evt)
3531 {
3532 struct ibmvfc_target *tgt = evt->tgt;
3533 struct ibmvfc_host *vhost = evt->vhost;
3534 struct ibmvfc_port_login *rsp = &evt->xfer_iu->plogi;
3535 u32 status = be16_to_cpu(rsp->common.status);
3536 int level = IBMVFC_DEFAULT_LOG_LEVEL;
3537
3538 vhost->discovery_threads--;
3539 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3540 switch (status) {
3541 case IBMVFC_MAD_SUCCESS:
3542 tgt_dbg(tgt, "Port Login succeeded\n");
3543 if (tgt->ids.port_name &&
3544 tgt->ids.port_name != wwn_to_u64(rsp->service_parms.port_name)) {
3545 vhost->reinit = 1;
3546 tgt_dbg(tgt, "Port re-init required\n");
3547 break;
3548 }
3549 tgt->ids.node_name = wwn_to_u64(rsp->service_parms.node_name);
3550 tgt->ids.port_name = wwn_to_u64(rsp->service_parms.port_name);
3551 tgt->ids.port_id = tgt->scsi_id;
3552 memcpy(&tgt->service_parms, &rsp->service_parms,
3553 sizeof(tgt->service_parms));
3554 memcpy(&tgt->service_parms_change, &rsp->service_parms_change,
3555 sizeof(tgt->service_parms_change));
3556 ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_prli);
3557 break;
3558 case IBMVFC_MAD_DRIVER_FAILED:
3559 break;
3560 case IBMVFC_MAD_CRQ_ERROR:
3561 ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
3562 break;
3563 case IBMVFC_MAD_FAILED:
3564 default:
3565 if (ibmvfc_retry_cmd(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)))
3566 level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
3567 else
3568 ibmvfc_del_tgt(tgt);
3569
3570 tgt_log(tgt, level, "Port Login failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
3571 ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
3572 be16_to_cpu(rsp->status), be16_to_cpu(rsp->error),
3573 ibmvfc_get_fc_type(be16_to_cpu(rsp->fc_type)), be16_to_cpu(rsp->fc_type),
3574 ibmvfc_get_ls_explain(be16_to_cpu(rsp->fc_explain)), be16_to_cpu(rsp->fc_explain), status);
3575 break;
3576 }
3577
3578 kref_put(&tgt->kref, ibmvfc_release_tgt);
3579 ibmvfc_free_event(evt);
3580 wake_up(&vhost->work_wait_q);
3581 }
3582
3583 /**
3584 * ibmvfc_tgt_send_plogi - Send PLOGI to the specified target
3585 * @tgt: ibmvfc target struct
3586 *
3587 **/
3588 static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *tgt)
3589 {
3590 struct ibmvfc_port_login *plogi;
3591 struct ibmvfc_host *vhost = tgt->vhost;
3592 struct ibmvfc_event *evt;
3593
3594 if (vhost->discovery_threads >= disc_threads)
3595 return;
3596
3597 kref_get(&tgt->kref);
3598 tgt->logo_rcvd = 0;
3599 evt = ibmvfc_get_event(vhost);
3600 vhost->discovery_threads++;
3601 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
3602 ibmvfc_init_event(evt, ibmvfc_tgt_plogi_done, IBMVFC_MAD_FORMAT);
3603 evt->tgt = tgt;
3604 plogi = &evt->iu.plogi;
3605 memset(plogi, 0, sizeof(*plogi));
3606 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN)) {
3607 plogi->common.version = cpu_to_be32(2);
3608 plogi->target_wwpn = cpu_to_be64(tgt->wwpn);
3609 } else {
3610 plogi->common.version = cpu_to_be32(1);
3611 }
3612 plogi->common.opcode = cpu_to_be32(IBMVFC_PORT_LOGIN);
3613 plogi->common.length = cpu_to_be16(sizeof(*plogi));
3614 plogi->scsi_id = cpu_to_be64(tgt->scsi_id);
3615
3616 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3617 vhost->discovery_threads--;
3618 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3619 kref_put(&tgt->kref, ibmvfc_release_tgt);
3620 } else
3621 tgt_dbg(tgt, "Sent port login\n");
3622 }
3623
3624 /**
3625 * ibmvfc_tgt_implicit_logout_done - Completion handler for Implicit Logout MAD
3626 * @evt: ibmvfc event struct
3627 *
3628 **/
3629 static void ibmvfc_tgt_implicit_logout_done(struct ibmvfc_event *evt)
3630 {
3631 struct ibmvfc_target *tgt = evt->tgt;
3632 struct ibmvfc_host *vhost = evt->vhost;
3633 struct ibmvfc_implicit_logout *rsp = &evt->xfer_iu->implicit_logout;
3634 u32 status = be16_to_cpu(rsp->common.status);
3635
3636 vhost->discovery_threads--;
3637 ibmvfc_free_event(evt);
3638 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3639
3640 switch (status) {
3641 case IBMVFC_MAD_SUCCESS:
3642 tgt_dbg(tgt, "Implicit Logout succeeded\n");
3643 break;
3644 case IBMVFC_MAD_DRIVER_FAILED:
3645 kref_put(&tgt->kref, ibmvfc_release_tgt);
3646 wake_up(&vhost->work_wait_q);
3647 return;
3648 case IBMVFC_MAD_FAILED:
3649 default:
3650 tgt_err(tgt, "Implicit Logout failed: rc=0x%02X\n", status);
3651 break;
3652 }
3653
3654 ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_plogi);
3655 kref_put(&tgt->kref, ibmvfc_release_tgt);
3656 wake_up(&vhost->work_wait_q);
3657 }
3658
3659 /**
3660 * __ibmvfc_tgt_get_implicit_logout_evt - Allocate and init an event for implicit logout
3661 * @tgt: ibmvfc target struct
3662 *
3663 * Returns:
3664 * Allocated and initialized ibmvfc_event struct
3665 **/
3666 static struct ibmvfc_event *__ibmvfc_tgt_get_implicit_logout_evt(struct ibmvfc_target *tgt,
3667 void (*done) (struct ibmvfc_event *))
3668 {
3669 struct ibmvfc_implicit_logout *mad;
3670 struct ibmvfc_host *vhost = tgt->vhost;
3671 struct ibmvfc_event *evt;
3672
3673 kref_get(&tgt->kref);
3674 evt = ibmvfc_get_event(vhost);
3675 ibmvfc_init_event(evt, done, IBMVFC_MAD_FORMAT);
3676 evt->tgt = tgt;
3677 mad = &evt->iu.implicit_logout;
3678 memset(mad, 0, sizeof(*mad));
3679 mad->common.version = cpu_to_be32(1);
3680 mad->common.opcode = cpu_to_be32(IBMVFC_IMPLICIT_LOGOUT);
3681 mad->common.length = cpu_to_be16(sizeof(*mad));
3682 mad->old_scsi_id = cpu_to_be64(tgt->scsi_id);
3683 return evt;
3684 }
3685
3686 /**
3687 * ibmvfc_tgt_implicit_logout - Initiate an Implicit Logout for specified target
3688 * @tgt: ibmvfc target struct
3689 *
3690 **/
3691 static void ibmvfc_tgt_implicit_logout(struct ibmvfc_target *tgt)
3692 {
3693 struct ibmvfc_host *vhost = tgt->vhost;
3694 struct ibmvfc_event *evt;
3695
3696 if (vhost->discovery_threads >= disc_threads)
3697 return;
3698
3699 vhost->discovery_threads++;
3700 evt = __ibmvfc_tgt_get_implicit_logout_evt(tgt,
3701 ibmvfc_tgt_implicit_logout_done);
3702
3703 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
3704 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3705 vhost->discovery_threads--;
3706 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3707 kref_put(&tgt->kref, ibmvfc_release_tgt);
3708 } else
3709 tgt_dbg(tgt, "Sent Implicit Logout\n");
3710 }
3711
3712 /**
3713 * ibmvfc_tgt_implicit_logout_and_del_done - Completion handler for Implicit Logout MAD
3714 * @evt: ibmvfc event struct
3715 *
3716 **/
3717 static void ibmvfc_tgt_implicit_logout_and_del_done(struct ibmvfc_event *evt)
3718 {
3719 struct ibmvfc_target *tgt = evt->tgt;
3720 struct ibmvfc_host *vhost = evt->vhost;
3721 struct ibmvfc_passthru_mad *mad = &evt->xfer_iu->passthru;
3722 u32 status = be16_to_cpu(mad->common.status);
3723
3724 vhost->discovery_threads--;
3725 ibmvfc_free_event(evt);
3726
3727 /*
3728 * If our state is IBMVFC_HOST_OFFLINE, we could be unloading the
3729 * driver in which case we need to free up all the targets. If we are
3730 * not unloading, we will still go through a hard reset to get out of
3731 * offline state, so there is no need to track the old targets in that
3732 * case.
3733 */
3734 if (status == IBMVFC_MAD_SUCCESS || vhost->state == IBMVFC_HOST_OFFLINE)
3735 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
3736 else
3737 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_AND_LOGOUT_RPORT);
3738
3739 tgt_dbg(tgt, "Implicit Logout %s\n", (status == IBMVFC_MAD_SUCCESS) ? "succeeded" : "failed");
3740 kref_put(&tgt->kref, ibmvfc_release_tgt);
3741 wake_up(&vhost->work_wait_q);
3742 }
3743
3744 /**
3745 * ibmvfc_tgt_implicit_logout_and_del - Initiate an Implicit Logout for specified target
3746 * @tgt: ibmvfc target struct
3747 *
3748 **/
3749 static void ibmvfc_tgt_implicit_logout_and_del(struct ibmvfc_target *tgt)
3750 {
3751 struct ibmvfc_host *vhost = tgt->vhost;
3752 struct ibmvfc_event *evt;
3753
3754 if (!vhost->logged_in) {
3755 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
3756 return;
3757 }
3758
3759 if (vhost->discovery_threads >= disc_threads)
3760 return;
3761
3762 vhost->discovery_threads++;
3763 evt = __ibmvfc_tgt_get_implicit_logout_evt(tgt,
3764 ibmvfc_tgt_implicit_logout_and_del_done);
3765
3766 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_LOGOUT_RPORT_WAIT);
3767 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3768 vhost->discovery_threads--;
3769 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
3770 kref_put(&tgt->kref, ibmvfc_release_tgt);
3771 } else
3772 tgt_dbg(tgt, "Sent Implicit Logout\n");
3773 }
3774
3775 /**
3776 * ibmvfc_tgt_move_login_done - Completion handler for Move Login
3777 * @evt: ibmvfc event struct
3778 *
3779 **/
3780 static void ibmvfc_tgt_move_login_done(struct ibmvfc_event *evt)
3781 {
3782 struct ibmvfc_target *tgt = evt->tgt;
3783 struct ibmvfc_host *vhost = evt->vhost;
3784 struct ibmvfc_move_login *rsp = &evt->xfer_iu->move_login;
3785 u32 status = be16_to_cpu(rsp->common.status);
3786 int level = IBMVFC_DEFAULT_LOG_LEVEL;
3787
3788 vhost->discovery_threads--;
3789 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3790 switch (status) {
3791 case IBMVFC_MAD_SUCCESS:
3792 tgt_dbg(tgt, "Move Login succeeded for old scsi_id: %llX\n", tgt->old_scsi_id);
3793 tgt->ids.node_name = wwn_to_u64(rsp->service_parms.node_name);
3794 tgt->ids.port_name = wwn_to_u64(rsp->service_parms.port_name);
3795 tgt->ids.port_id = tgt->scsi_id;
3796 memcpy(&tgt->service_parms, &rsp->service_parms,
3797 sizeof(tgt->service_parms));
3798 memcpy(&tgt->service_parms_change, &rsp->service_parms_change,
3799 sizeof(tgt->service_parms_change));
3800 ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_prli);
3801 break;
3802 case IBMVFC_MAD_DRIVER_FAILED:
3803 break;
3804 case IBMVFC_MAD_CRQ_ERROR:
3805 ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_move_login);
3806 break;
3807 case IBMVFC_MAD_FAILED:
3808 default:
3809 level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_move_login);
3810
3811 tgt_log(tgt, level,
3812 "Move Login failed: old scsi_id: %llX, flags:%x, vios_flags:%x, rc=0x%02X\n",
3813 tgt->old_scsi_id, be32_to_cpu(rsp->flags), be16_to_cpu(rsp->vios_flags),
3814 status);
3815 break;
3816 }
3817
3818 kref_put(&tgt->kref, ibmvfc_release_tgt);
3819 ibmvfc_free_event(evt);
3820 wake_up(&vhost->work_wait_q);
3821 }
3822
3823
3824 /**
3825 * ibmvfc_tgt_move_login - Initiate a move login for specified target
3826 * @tgt: ibmvfc target struct
3827 *
3828 **/
3829 static void ibmvfc_tgt_move_login(struct ibmvfc_target *tgt)
3830 {
3831 struct ibmvfc_host *vhost = tgt->vhost;
3832 struct ibmvfc_move_login *move;
3833 struct ibmvfc_event *evt;
3834
3835 if (vhost->discovery_threads >= disc_threads)
3836 return;
3837
3838 kref_get(&tgt->kref);
3839 evt = ibmvfc_get_event(vhost);
3840 vhost->discovery_threads++;
3841 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
3842 ibmvfc_init_event(evt, ibmvfc_tgt_move_login_done, IBMVFC_MAD_FORMAT);
3843 evt->tgt = tgt;
3844 move = &evt->iu.move_login;
3845 memset(move, 0, sizeof(*move));
3846 move->common.version = cpu_to_be32(1);
3847 move->common.opcode = cpu_to_be32(IBMVFC_MOVE_LOGIN);
3848 move->common.length = cpu_to_be16(sizeof(*move));
3849
3850 move->old_scsi_id = cpu_to_be64(tgt->old_scsi_id);
3851 move->new_scsi_id = cpu_to_be64(tgt->scsi_id);
3852 move->wwpn = cpu_to_be64(tgt->wwpn);
3853 move->node_name = cpu_to_be64(tgt->ids.node_name);
3854
3855 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3856 vhost->discovery_threads--;
3857 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
3858 kref_put(&tgt->kref, ibmvfc_release_tgt);
3859 } else
3860 tgt_dbg(tgt, "Sent Move Login for old scsi_id: %llX\n", tgt->old_scsi_id);
3861 }
3862
3863 /**
3864 * ibmvfc_adisc_needs_plogi - Does device need PLOGI?
3865 * @mad: ibmvfc passthru mad struct
3866 * @tgt: ibmvfc target struct
3867 *
3868 * Returns:
3869 * 1 if PLOGI needed / 0 if PLOGI not needed
3870 **/
3871 static int ibmvfc_adisc_needs_plogi(struct ibmvfc_passthru_mad *mad,
3872 struct ibmvfc_target *tgt)
3873 {
3874 if (wwn_to_u64((u8 *)&mad->fc_iu.response[2]) != tgt->ids.port_name)
3875 return 1;
3876 if (wwn_to_u64((u8 *)&mad->fc_iu.response[4]) != tgt->ids.node_name)
3877 return 1;
3878 if (be32_to_cpu(mad->fc_iu.response[6]) != tgt->scsi_id)
3879 return 1;
3880 return 0;
3881 }
3882
3883 /**
3884 * ibmvfc_tgt_adisc_done - Completion handler for ADISC
3885 * @evt: ibmvfc event struct
3886 *
3887 **/
3888 static void ibmvfc_tgt_adisc_done(struct ibmvfc_event *evt)
3889 {
3890 struct ibmvfc_target *tgt = evt->tgt;
3891 struct ibmvfc_host *vhost = evt->vhost;
3892 struct ibmvfc_passthru_mad *mad = &evt->xfer_iu->passthru;
3893 u32 status = be16_to_cpu(mad->common.status);
3894 u8 fc_reason, fc_explain;
3895
3896 vhost->discovery_threads--;
3897 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3898 del_timer(&tgt->timer);
3899
3900 switch (status) {
3901 case IBMVFC_MAD_SUCCESS:
3902 tgt_dbg(tgt, "ADISC succeeded\n");
3903 if (ibmvfc_adisc_needs_plogi(mad, tgt))
3904 ibmvfc_del_tgt(tgt);
3905 break;
3906 case IBMVFC_MAD_DRIVER_FAILED:
3907 break;
3908 case IBMVFC_MAD_FAILED:
3909 default:
3910 ibmvfc_del_tgt(tgt);
3911 fc_reason = (be32_to_cpu(mad->fc_iu.response[1]) & 0x00ff0000) >> 16;
3912 fc_explain = (be32_to_cpu(mad->fc_iu.response[1]) & 0x0000ff00) >> 8;
3913 tgt_info(tgt, "ADISC failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
3914 ibmvfc_get_cmd_error(be16_to_cpu(mad->iu.status), be16_to_cpu(mad->iu.error)),
3915 be16_to_cpu(mad->iu.status), be16_to_cpu(mad->iu.error),
3916 ibmvfc_get_fc_type(fc_reason), fc_reason,
3917 ibmvfc_get_ls_explain(fc_explain), fc_explain, status);
3918 break;
3919 }
3920
3921 kref_put(&tgt->kref, ibmvfc_release_tgt);
3922 ibmvfc_free_event(evt);
3923 wake_up(&vhost->work_wait_q);
3924 }
3925
3926 /**
3927 * ibmvfc_init_passthru - Initialize an event struct for FC passthru
3928 * @evt: ibmvfc event struct
3929 *
3930 **/
3931 static void ibmvfc_init_passthru(struct ibmvfc_event *evt)
3932 {
3933 struct ibmvfc_passthru_mad *mad = &evt->iu.passthru;
3934
3935 memset(mad, 0, sizeof(*mad));
3936 mad->common.version = cpu_to_be32(1);
3937 mad->common.opcode = cpu_to_be32(IBMVFC_PASSTHRU);
3938 mad->common.length = cpu_to_be16(sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu));
3939 mad->cmd_ioba.va = cpu_to_be64((u64)be64_to_cpu(evt->crq.ioba) +
3940 offsetof(struct ibmvfc_passthru_mad, iu));
3941 mad->cmd_ioba.len = cpu_to_be32(sizeof(mad->iu));
3942 mad->iu.cmd_len = cpu_to_be32(sizeof(mad->fc_iu.payload));
3943 mad->iu.rsp_len = cpu_to_be32(sizeof(mad->fc_iu.response));
3944 mad->iu.cmd.va = cpu_to_be64((u64)be64_to_cpu(evt->crq.ioba) +
3945 offsetof(struct ibmvfc_passthru_mad, fc_iu) +
3946 offsetof(struct ibmvfc_passthru_fc_iu, payload));
3947 mad->iu.cmd.len = cpu_to_be32(sizeof(mad->fc_iu.payload));
3948 mad->iu.rsp.va = cpu_to_be64((u64)be64_to_cpu(evt->crq.ioba) +
3949 offsetof(struct ibmvfc_passthru_mad, fc_iu) +
3950 offsetof(struct ibmvfc_passthru_fc_iu, response));
3951 mad->iu.rsp.len = cpu_to_be32(sizeof(mad->fc_iu.response));
3952 }
3953
3954 /**
3955 * ibmvfc_tgt_adisc_cancel_done - Completion handler when cancelling an ADISC
3956 * @evt: ibmvfc event struct
3957 *
3958 * Just cleanup this event struct. Everything else is handled by
3959 * the ADISC completion handler. If the ADISC never actually comes
3960 * back, we still have the timer running on the ADISC event struct
3961 * which will fire and cause the CRQ to get reset.
3962 *
3963 **/
3964 static void ibmvfc_tgt_adisc_cancel_done(struct ibmvfc_event *evt)
3965 {
3966 struct ibmvfc_host *vhost = evt->vhost;
3967 struct ibmvfc_target *tgt = evt->tgt;
3968
3969 tgt_dbg(tgt, "ADISC cancel complete\n");
3970 vhost->abort_threads--;
3971 ibmvfc_free_event(evt);
3972 kref_put(&tgt->kref, ibmvfc_release_tgt);
3973 wake_up(&vhost->work_wait_q);
3974 }
3975
3976 /**
3977 * ibmvfc_adisc_timeout - Handle an ADISC timeout
3978 * @tgt: ibmvfc target struct
3979 *
3980 * If an ADISC times out, send a cancel. If the cancel times
3981 * out, reset the CRQ. When the ADISC comes back as cancelled,
3982 * log back into the target.
3983 **/
3984 static void ibmvfc_adisc_timeout(struct timer_list *t)
3985 {
3986 struct ibmvfc_target *tgt = from_timer(tgt, t, timer);
3987 struct ibmvfc_host *vhost = tgt->vhost;
3988 struct ibmvfc_event *evt;
3989 struct ibmvfc_tmf *tmf;
3990 unsigned long flags;
3991 int rc;
3992
3993 tgt_dbg(tgt, "ADISC timeout\n");
3994 spin_lock_irqsave(vhost->host->host_lock, flags);
3995 if (vhost->abort_threads >= disc_threads ||
3996 tgt->action != IBMVFC_TGT_ACTION_INIT_WAIT ||
3997 vhost->state != IBMVFC_INITIALIZING ||
3998 vhost->action != IBMVFC_HOST_ACTION_QUERY_TGTS) {
3999 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4000 return;
4001 }
4002
4003 vhost->abort_threads++;
4004 kref_get(&tgt->kref);
4005 evt = ibmvfc_get_event(vhost);
4006 ibmvfc_init_event(evt, ibmvfc_tgt_adisc_cancel_done, IBMVFC_MAD_FORMAT);
4007
4008 evt->tgt = tgt;
4009 tmf = &evt->iu.tmf;
4010 memset(tmf, 0, sizeof(*tmf));
4011 if (ibmvfc_check_caps(vhost, IBMVFC_HANDLE_VF_WWPN)) {
4012 tmf->common.version = cpu_to_be32(2);
4013 tmf->target_wwpn = cpu_to_be64(tgt->wwpn);
4014 } else {
4015 tmf->common.version = cpu_to_be32(1);
4016 }
4017 tmf->common.opcode = cpu_to_be32(IBMVFC_TMF_MAD);
4018 tmf->common.length = cpu_to_be16(sizeof(*tmf));
4019 tmf->scsi_id = cpu_to_be64(tgt->scsi_id);
4020 tmf->cancel_key = cpu_to_be32(tgt->cancel_key);
4021
4022 rc = ibmvfc_send_event(evt, vhost, default_timeout);
4023
4024 if (rc) {
4025 tgt_err(tgt, "Failed to send cancel event for ADISC. rc=%d\n", rc);
4026 vhost->abort_threads--;
4027 kref_put(&tgt->kref, ibmvfc_release_tgt);
4028 __ibmvfc_reset_host(vhost);
4029 } else
4030 tgt_dbg(tgt, "Attempting to cancel ADISC\n");
4031 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4032 }
4033
4034 /**
4035 * ibmvfc_tgt_adisc - Initiate an ADISC for specified target
4036 * @tgt: ibmvfc target struct
4037 *
4038 * When sending an ADISC we end up with two timers running. The
4039 * first timer is the timer in the ibmvfc target struct. If this
4040 * fires, we send a cancel to the target. The second timer is the
4041 * timer on the ibmvfc event for the ADISC, which is longer. If that
4042 * fires, it means the ADISC timed out and our attempt to cancel it
4043 * also failed, so we need to reset the CRQ.
4044 **/
4045 static void ibmvfc_tgt_adisc(struct ibmvfc_target *tgt)
4046 {
4047 struct ibmvfc_passthru_mad *mad;
4048 struct ibmvfc_host *vhost = tgt->vhost;
4049 struct ibmvfc_event *evt;
4050
4051 if (vhost->discovery_threads >= disc_threads)
4052 return;
4053
4054 kref_get(&tgt->kref);
4055 evt = ibmvfc_get_event(vhost);
4056 vhost->discovery_threads++;
4057 ibmvfc_init_event(evt, ibmvfc_tgt_adisc_done, IBMVFC_MAD_FORMAT);
4058 evt->tgt = tgt;
4059
4060 ibmvfc_init_passthru(evt);
4061 mad = &evt->iu.passthru;
4062 mad->iu.flags = cpu_to_be32(IBMVFC_FC_ELS);
4063 mad->iu.scsi_id = cpu_to_be64(tgt->scsi_id);
4064 mad->iu.cancel_key = cpu_to_be32(tgt->cancel_key);
4065
4066 mad->fc_iu.payload[0] = cpu_to_be32(IBMVFC_ADISC);
4067 memcpy(&mad->fc_iu.payload[2], &vhost->login_buf->resp.port_name,
4068 sizeof(vhost->login_buf->resp.port_name));
4069 memcpy(&mad->fc_iu.payload[4], &vhost->login_buf->resp.node_name,
4070 sizeof(vhost->login_buf->resp.node_name));
4071 mad->fc_iu.payload[6] = cpu_to_be32(be64_to_cpu(vhost->login_buf->resp.scsi_id) & 0x00ffffff);
4072
4073 if (timer_pending(&tgt->timer))
4074 mod_timer(&tgt->timer, jiffies + (IBMVFC_ADISC_TIMEOUT * HZ));
4075 else {
4076 tgt->timer.expires = jiffies + (IBMVFC_ADISC_TIMEOUT * HZ);
4077 add_timer(&tgt->timer);
4078 }
4079
4080 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
4081 if (ibmvfc_send_event(evt, vhost, IBMVFC_ADISC_PLUS_CANCEL_TIMEOUT)) {
4082 vhost->discovery_threads--;
4083 del_timer(&tgt->timer);
4084 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
4085 kref_put(&tgt->kref, ibmvfc_release_tgt);
4086 } else
4087 tgt_dbg(tgt, "Sent ADISC\n");
4088 }
4089
4090 /**
4091 * ibmvfc_tgt_query_target_done - Completion handler for Query Target MAD
4092 * @evt: ibmvfc event struct
4093 *
4094 **/
4095 static void ibmvfc_tgt_query_target_done(struct ibmvfc_event *evt)
4096 {
4097 struct ibmvfc_target *tgt = evt->tgt;
4098 struct ibmvfc_host *vhost = evt->vhost;
4099 struct ibmvfc_query_tgt *rsp = &evt->xfer_iu->query_tgt;
4100 u32 status = be16_to_cpu(rsp->common.status);
4101 int level = IBMVFC_DEFAULT_LOG_LEVEL;
4102
4103 vhost->discovery_threads--;
4104 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
4105 switch (status) {
4106 case IBMVFC_MAD_SUCCESS:
4107 tgt_dbg(tgt, "Query Target succeeded\n");
4108 if (be64_to_cpu(rsp->scsi_id) != tgt->scsi_id)
4109 ibmvfc_del_tgt(tgt);
4110 else
4111 ibmvfc_init_tgt(tgt, ibmvfc_tgt_adisc);
4112 break;
4113 case IBMVFC_MAD_DRIVER_FAILED:
4114 break;
4115 case IBMVFC_MAD_CRQ_ERROR:
4116 ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
4117 break;
4118 case IBMVFC_MAD_FAILED:
4119 default:
4120 if ((be16_to_cpu(rsp->status) & IBMVFC_FABRIC_MAPPED) == IBMVFC_FABRIC_MAPPED &&
4121 be16_to_cpu(rsp->error) == IBMVFC_UNABLE_TO_PERFORM_REQ &&
4122 be16_to_cpu(rsp->fc_explain) == IBMVFC_PORT_NAME_NOT_REG)
4123 ibmvfc_del_tgt(tgt);
4124 else if (ibmvfc_retry_cmd(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)))
4125 level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
4126 else
4127 ibmvfc_del_tgt(tgt);
4128
4129 tgt_log(tgt, level, "Query Target failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
4130 ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
4131 be16_to_cpu(rsp->status), be16_to_cpu(rsp->error),
4132 ibmvfc_get_fc_type(be16_to_cpu(rsp->fc_type)), be16_to_cpu(rsp->fc_type),
4133 ibmvfc_get_gs_explain(be16_to_cpu(rsp->fc_explain)), be16_to_cpu(rsp->fc_explain),
4134 status);
4135 break;
4136 }
4137
4138 kref_put(&tgt->kref, ibmvfc_release_tgt);
4139 ibmvfc_free_event(evt);
4140 wake_up(&vhost->work_wait_q);
4141 }
4142
4143 /**
4144 * ibmvfc_tgt_query_target - Initiate a Query Target for specified target
4145 * @tgt: ibmvfc target struct
4146 *
4147 **/
4148 static void ibmvfc_tgt_query_target(struct ibmvfc_target *tgt)
4149 {
4150 struct ibmvfc_query_tgt *query_tgt;
4151 struct ibmvfc_host *vhost = tgt->vhost;
4152 struct ibmvfc_event *evt;
4153
4154 if (vhost->discovery_threads >= disc_threads)
4155 return;
4156
4157 kref_get(&tgt->kref);
4158 evt = ibmvfc_get_event(vhost);
4159 vhost->discovery_threads++;
4160 evt->tgt = tgt;
4161 ibmvfc_init_event(evt, ibmvfc_tgt_query_target_done, IBMVFC_MAD_FORMAT);
4162 query_tgt = &evt->iu.query_tgt;
4163 memset(query_tgt, 0, sizeof(*query_tgt));
4164 query_tgt->common.version = cpu_to_be32(1);
4165 query_tgt->common.opcode = cpu_to_be32(IBMVFC_QUERY_TARGET);
4166 query_tgt->common.length = cpu_to_be16(sizeof(*query_tgt));
4167 query_tgt->wwpn = cpu_to_be64(tgt->ids.port_name);
4168
4169 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
4170 if (ibmvfc_send_event(evt, vhost, default_timeout)) {
4171 vhost->discovery_threads--;
4172 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
4173 kref_put(&tgt->kref, ibmvfc_release_tgt);
4174 } else
4175 tgt_dbg(tgt, "Sent Query Target\n");
4176 }
4177
4178 /**
4179 * ibmvfc_alloc_target - Allocate and initialize an ibmvfc target
4180 * @vhost: ibmvfc host struct
4181 * @scsi_id: SCSI ID to allocate target for
4182 *
4183 * Returns:
4184 * 0 on success / other on failure
4185 **/
4186 static int ibmvfc_alloc_target(struct ibmvfc_host *vhost,
4187 struct ibmvfc_discover_targets_entry *target)
4188 {
4189 struct ibmvfc_target *stgt = NULL;
4190 struct ibmvfc_target *wtgt = NULL;
4191 struct ibmvfc_target *tgt;
4192 unsigned long flags;
4193 u64 scsi_id = be32_to_cpu(target->scsi_id) & IBMVFC_DISC_TGT_SCSI_ID_MASK;
4194 u64 wwpn = be64_to_cpu(target->wwpn);
4195
4196 /* Look to see if we already have a target allocated for this SCSI ID or WWPN */
4197 spin_lock_irqsave(vhost->host->host_lock, flags);
4198 list_for_each_entry(tgt, &vhost->targets, queue) {
4199 if (tgt->wwpn == wwpn) {
4200 wtgt = tgt;
4201 break;
4202 }
4203 }
4204
4205 list_for_each_entry(tgt, &vhost->targets, queue) {
4206 if (tgt->scsi_id == scsi_id) {
4207 stgt = tgt;
4208 break;
4209 }
4210 }
4211
4212 if (wtgt && !stgt) {
4213 /*
4214 * A WWPN target has moved and we still are tracking the old
4215 * SCSI ID. The only way we should be able to get here is if
4216 * we attempted to send an implicit logout for the old SCSI ID
4217 * and it failed for some reason, such as there being I/O
4218 * pending to the target. In this case, we will have already
4219 * deleted the rport from the FC transport so we do a move
4220 * login, which works even with I/O pending, as it will cancel
4221 * any active commands.
4222 */
4223 if (wtgt->action == IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT) {
4224 /*
4225 * Do a move login here. The old target is no longer
4226 * known to the transport layer We don't use the
4227 * normal ibmvfc_set_tgt_action to set this, as we
4228 * don't normally want to allow this state change.
4229 */
4230 wtgt->old_scsi_id = wtgt->scsi_id;
4231 wtgt->scsi_id = scsi_id;
4232 wtgt->action = IBMVFC_TGT_ACTION_INIT;
4233 ibmvfc_init_tgt(wtgt, ibmvfc_tgt_move_login);
4234 goto unlock_out;
4235 } else {
4236 tgt_err(wtgt, "Unexpected target state: %d, %p\n",
4237 wtgt->action, wtgt->rport);
4238 }
4239 } else if (stgt) {
4240 if (tgt->need_login)
4241 ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
4242 goto unlock_out;
4243 }
4244 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4245
4246 tgt = mempool_alloc(vhost->tgt_pool, GFP_NOIO);
4247 memset(tgt, 0, sizeof(*tgt));
4248 tgt->scsi_id = scsi_id;
4249 tgt->wwpn = wwpn;
4250 tgt->vhost = vhost;
4251 tgt->need_login = 1;
4252 timer_setup(&tgt->timer, ibmvfc_adisc_timeout, 0);
4253 kref_init(&tgt->kref);
4254 ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
4255 spin_lock_irqsave(vhost->host->host_lock, flags);
4256 tgt->cancel_key = vhost->task_set++;
4257 list_add_tail(&tgt->queue, &vhost->targets);
4258
4259 unlock_out:
4260 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4261 return 0;
4262 }
4263
4264 /**
4265 * ibmvfc_alloc_targets - Allocate and initialize ibmvfc targets
4266 * @vhost: ibmvfc host struct
4267 *
4268 * Returns:
4269 * 0 on success / other on failure
4270 **/
4271 static int ibmvfc_alloc_targets(struct ibmvfc_host *vhost)
4272 {
4273 int i, rc;
4274
4275 for (i = 0, rc = 0; !rc && i < vhost->num_targets; i++)
4276 rc = ibmvfc_alloc_target(vhost, &vhost->disc_buf[i]);
4277
4278 return rc;
4279 }
4280
4281 /**
4282 * ibmvfc_discover_targets_done - Completion handler for discover targets MAD
4283 * @evt: ibmvfc event struct
4284 *
4285 **/
4286 static void ibmvfc_discover_targets_done(struct ibmvfc_event *evt)
4287 {
4288 struct ibmvfc_host *vhost = evt->vhost;
4289 struct ibmvfc_discover_targets *rsp = &evt->xfer_iu->discover_targets;
4290 u32 mad_status = be16_to_cpu(rsp->common.status);
4291 int level = IBMVFC_DEFAULT_LOG_LEVEL;
4292
4293 switch (mad_status) {
4294 case IBMVFC_MAD_SUCCESS:
4295 ibmvfc_dbg(vhost, "Discover Targets succeeded\n");
4296 vhost->num_targets = be32_to_cpu(rsp->num_written);
4297 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_ALLOC_TGTS);
4298 break;
4299 case IBMVFC_MAD_FAILED:
4300 level += ibmvfc_retry_host_init(vhost);
4301 ibmvfc_log(vhost, level, "Discover Targets failed: %s (%x:%x)\n",
4302 ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
4303 be16_to_cpu(rsp->status), be16_to_cpu(rsp->error));
4304 break;
4305 case IBMVFC_MAD_DRIVER_FAILED:
4306 break;
4307 default:
4308 dev_err(vhost->dev, "Invalid Discover Targets response: 0x%x\n", mad_status);
4309 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4310 break;
4311 }
4312
4313 ibmvfc_free_event(evt);
4314 wake_up(&vhost->work_wait_q);
4315 }
4316
4317 /**
4318 * ibmvfc_discover_targets - Send Discover Targets MAD
4319 * @vhost: ibmvfc host struct
4320 *
4321 **/
4322 static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)
4323 {
4324 struct ibmvfc_discover_targets *mad;
4325 struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
4326
4327 ibmvfc_init_event(evt, ibmvfc_discover_targets_done, IBMVFC_MAD_FORMAT);
4328 mad = &evt->iu.discover_targets;
4329 memset(mad, 0, sizeof(*mad));
4330 mad->common.version = cpu_to_be32(1);
4331 mad->common.opcode = cpu_to_be32(IBMVFC_DISC_TARGETS);
4332 mad->common.length = cpu_to_be16(sizeof(*mad));
4333 mad->bufflen = cpu_to_be32(vhost->disc_buf_sz);
4334 mad->buffer.va = cpu_to_be64(vhost->disc_buf_dma);
4335 mad->buffer.len = cpu_to_be32(vhost->disc_buf_sz);
4336 mad->flags = cpu_to_be32(IBMVFC_DISC_TGT_PORT_ID_WWPN_LIST);
4337 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
4338
4339 if (!ibmvfc_send_event(evt, vhost, default_timeout))
4340 ibmvfc_dbg(vhost, "Sent discover targets\n");
4341 else
4342 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4343 }
4344
4345 /**
4346 * ibmvfc_npiv_login_done - Completion handler for NPIV Login
4347 * @evt: ibmvfc event struct
4348 *
4349 **/
4350 static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
4351 {
4352 struct ibmvfc_host *vhost = evt->vhost;
4353 u32 mad_status = be16_to_cpu(evt->xfer_iu->npiv_login.common.status);
4354 struct ibmvfc_npiv_login_resp *rsp = &vhost->login_buf->resp;
4355 unsigned int npiv_max_sectors;
4356 int level = IBMVFC_DEFAULT_LOG_LEVEL;
4357
4358 switch (mad_status) {
4359 case IBMVFC_MAD_SUCCESS:
4360 ibmvfc_free_event(evt);
4361 break;
4362 case IBMVFC_MAD_FAILED:
4363 if (ibmvfc_retry_cmd(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)))
4364 level += ibmvfc_retry_host_init(vhost);
4365 else
4366 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4367 ibmvfc_log(vhost, level, "NPIV Login failed: %s (%x:%x)\n",
4368 ibmvfc_get_cmd_error(be16_to_cpu(rsp->status), be16_to_cpu(rsp->error)),
4369 be16_to_cpu(rsp->status), be16_to_cpu(rsp->error));
4370 ibmvfc_free_event(evt);
4371 return;
4372 case IBMVFC_MAD_CRQ_ERROR:
4373 ibmvfc_retry_host_init(vhost);
4374 fallthrough;
4375 case IBMVFC_MAD_DRIVER_FAILED:
4376 ibmvfc_free_event(evt);
4377 return;
4378 default:
4379 dev_err(vhost->dev, "Invalid NPIV Login response: 0x%x\n", mad_status);
4380 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4381 ibmvfc_free_event(evt);
4382 return;
4383 }
4384
4385 vhost->client_migrated = 0;
4386
4387 if (!(be32_to_cpu(rsp->flags) & IBMVFC_NATIVE_FC)) {
4388 dev_err(vhost->dev, "Virtual adapter does not support FC. %x\n",
4389 rsp->flags);
4390 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4391 wake_up(&vhost->work_wait_q);
4392 return;
4393 }
4394
4395 if (be32_to_cpu(rsp->max_cmds) <= IBMVFC_NUM_INTERNAL_REQ) {
4396 dev_err(vhost->dev, "Virtual adapter supported queue depth too small: %d\n",
4397 rsp->max_cmds);
4398 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4399 wake_up(&vhost->work_wait_q);
4400 return;
4401 }
4402
4403 vhost->logged_in = 1;
4404 npiv_max_sectors = min((uint)(be64_to_cpu(rsp->max_dma_len) >> 9), IBMVFC_MAX_SECTORS);
4405 dev_info(vhost->dev, "Host partition: %s, device: %s %s %s max sectors %u\n",
4406 rsp->partition_name, rsp->device_name, rsp->port_loc_code,
4407 rsp->drc_name, npiv_max_sectors);
4408
4409 fc_host_fabric_name(vhost->host) = be64_to_cpu(rsp->node_name);
4410 fc_host_node_name(vhost->host) = be64_to_cpu(rsp->node_name);
4411 fc_host_port_name(vhost->host) = be64_to_cpu(rsp->port_name);
4412 fc_host_port_id(vhost->host) = be64_to_cpu(rsp->scsi_id);
4413 fc_host_port_type(vhost->host) = FC_PORTTYPE_NPIV;
4414 fc_host_supported_classes(vhost->host) = 0;
4415 if (be32_to_cpu(rsp->service_parms.class1_parms[0]) & 0x80000000)
4416 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS1;
4417 if (be32_to_cpu(rsp->service_parms.class2_parms[0]) & 0x80000000)
4418 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS2;
4419 if (be32_to_cpu(rsp->service_parms.class3_parms[0]) & 0x80000000)
4420 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS3;
4421 fc_host_maxframe_size(vhost->host) =
4422 be16_to_cpu(rsp->service_parms.common.bb_rcv_sz) & 0x0fff;
4423
4424 vhost->host->can_queue = be32_to_cpu(rsp->max_cmds) - IBMVFC_NUM_INTERNAL_REQ;
4425 vhost->host->max_sectors = npiv_max_sectors;
4426 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
4427 wake_up(&vhost->work_wait_q);
4428 }
4429
4430 /**
4431 * ibmvfc_npiv_login - Sends NPIV login
4432 * @vhost: ibmvfc host struct
4433 *
4434 **/
4435 static void ibmvfc_npiv_login(struct ibmvfc_host *vhost)
4436 {
4437 struct ibmvfc_npiv_login_mad *mad;
4438 struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
4439
4440 ibmvfc_gather_partition_info(vhost);
4441 ibmvfc_set_login_info(vhost);
4442 ibmvfc_init_event(evt, ibmvfc_npiv_login_done, IBMVFC_MAD_FORMAT);
4443
4444 memcpy(vhost->login_buf, &vhost->login_info, sizeof(vhost->login_info));
4445 mad = &evt->iu.npiv_login;
4446 memset(mad, 0, sizeof(struct ibmvfc_npiv_login_mad));
4447 mad->common.version = cpu_to_be32(1);
4448 mad->common.opcode = cpu_to_be32(IBMVFC_NPIV_LOGIN);
4449 mad->common.length = cpu_to_be16(sizeof(struct ibmvfc_npiv_login_mad));
4450 mad->buffer.va = cpu_to_be64(vhost->login_buf_dma);
4451 mad->buffer.len = cpu_to_be32(sizeof(*vhost->login_buf));
4452
4453 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
4454
4455 if (!ibmvfc_send_event(evt, vhost, default_timeout))
4456 ibmvfc_dbg(vhost, "Sent NPIV login\n");
4457 else
4458 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4459 }
4460
4461 /**
4462 * ibmvfc_npiv_logout_done - Completion handler for NPIV Logout
4463 * @vhost: ibmvfc host struct
4464 *
4465 **/
4466 static void ibmvfc_npiv_logout_done(struct ibmvfc_event *evt)
4467 {
4468 struct ibmvfc_host *vhost = evt->vhost;
4469 u32 mad_status = be16_to_cpu(evt->xfer_iu->npiv_logout.common.status);
4470
4471 ibmvfc_free_event(evt);
4472
4473 switch (mad_status) {
4474 case IBMVFC_MAD_SUCCESS:
4475 if (list_empty(&vhost->sent) &&
4476 vhost->action == IBMVFC_HOST_ACTION_LOGO_WAIT) {
4477 ibmvfc_init_host(vhost);
4478 return;
4479 }
4480 break;
4481 case IBMVFC_MAD_FAILED:
4482 case IBMVFC_MAD_NOT_SUPPORTED:
4483 case IBMVFC_MAD_CRQ_ERROR:
4484 case IBMVFC_MAD_DRIVER_FAILED:
4485 default:
4486 ibmvfc_dbg(vhost, "NPIV Logout failed. 0x%X\n", mad_status);
4487 break;
4488 }
4489
4490 ibmvfc_hard_reset_host(vhost);
4491 }
4492
4493 /**
4494 * ibmvfc_npiv_logout - Issue an NPIV Logout
4495 * @vhost: ibmvfc host struct
4496 *
4497 **/
4498 static void ibmvfc_npiv_logout(struct ibmvfc_host *vhost)
4499 {
4500 struct ibmvfc_npiv_logout_mad *mad;
4501 struct ibmvfc_event *evt;
4502
4503 evt = ibmvfc_get_event(vhost);
4504 ibmvfc_init_event(evt, ibmvfc_npiv_logout_done, IBMVFC_MAD_FORMAT);
4505
4506 mad = &evt->iu.npiv_logout;
4507 memset(mad, 0, sizeof(*mad));
4508 mad->common.version = cpu_to_be32(1);
4509 mad->common.opcode = cpu_to_be32(IBMVFC_NPIV_LOGOUT);
4510 mad->common.length = cpu_to_be16(sizeof(struct ibmvfc_npiv_logout_mad));
4511
4512 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO_WAIT);
4513
4514 if (!ibmvfc_send_event(evt, vhost, default_timeout))
4515 ibmvfc_dbg(vhost, "Sent NPIV logout\n");
4516 else
4517 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4518 }
4519
4520 /**
4521 * ibmvfc_dev_init_to_do - Is there target initialization work to do?
4522 * @vhost: ibmvfc host struct
4523 *
4524 * Returns:
4525 * 1 if work to do / 0 if not
4526 **/
4527 static int ibmvfc_dev_init_to_do(struct ibmvfc_host *vhost)
4528 {
4529 struct ibmvfc_target *tgt;
4530
4531 list_for_each_entry(tgt, &vhost->targets, queue) {
4532 if (tgt->action == IBMVFC_TGT_ACTION_INIT ||
4533 tgt->action == IBMVFC_TGT_ACTION_INIT_WAIT)
4534 return 1;
4535 }
4536
4537 return 0;
4538 }
4539
4540 /**
4541 * ibmvfc_dev_logo_to_do - Is there target logout work to do?
4542 * @vhost: ibmvfc host struct
4543 *
4544 * Returns:
4545 * 1 if work to do / 0 if not
4546 **/
4547 static int ibmvfc_dev_logo_to_do(struct ibmvfc_host *vhost)
4548 {
4549 struct ibmvfc_target *tgt;
4550
4551 list_for_each_entry(tgt, &vhost->targets, queue) {
4552 if (tgt->action == IBMVFC_TGT_ACTION_LOGOUT_RPORT ||
4553 tgt->action == IBMVFC_TGT_ACTION_LOGOUT_RPORT_WAIT)
4554 return 1;
4555 }
4556 return 0;
4557 }
4558
4559 /**
4560 * __ibmvfc_work_to_do - Is there task level work to do? (no locking)
4561 * @vhost: ibmvfc host struct
4562 *
4563 * Returns:
4564 * 1 if work to do / 0 if not
4565 **/
4566 static int __ibmvfc_work_to_do(struct ibmvfc_host *vhost)
4567 {
4568 struct ibmvfc_target *tgt;
4569
4570 if (kthread_should_stop())
4571 return 1;
4572 switch (vhost->action) {
4573 case IBMVFC_HOST_ACTION_NONE:
4574 case IBMVFC_HOST_ACTION_INIT_WAIT:
4575 case IBMVFC_HOST_ACTION_LOGO_WAIT:
4576 return 0;
4577 case IBMVFC_HOST_ACTION_TGT_INIT:
4578 case IBMVFC_HOST_ACTION_QUERY_TGTS:
4579 if (vhost->discovery_threads == disc_threads)
4580 return 0;
4581 list_for_each_entry(tgt, &vhost->targets, queue)
4582 if (tgt->action == IBMVFC_TGT_ACTION_INIT)
4583 return 1;
4584 list_for_each_entry(tgt, &vhost->targets, queue)
4585 if (tgt->action == IBMVFC_TGT_ACTION_INIT_WAIT)
4586 return 0;
4587 return 1;
4588 case IBMVFC_HOST_ACTION_TGT_DEL:
4589 case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
4590 if (vhost->discovery_threads == disc_threads)
4591 return 0;
4592 list_for_each_entry(tgt, &vhost->targets, queue)
4593 if (tgt->action == IBMVFC_TGT_ACTION_LOGOUT_RPORT)
4594 return 1;
4595 list_for_each_entry(tgt, &vhost->targets, queue)
4596 if (tgt->action == IBMVFC_TGT_ACTION_LOGOUT_RPORT_WAIT)
4597 return 0;
4598 return 1;
4599 case IBMVFC_HOST_ACTION_LOGO:
4600 case IBMVFC_HOST_ACTION_INIT:
4601 case IBMVFC_HOST_ACTION_ALLOC_TGTS:
4602 case IBMVFC_HOST_ACTION_QUERY:
4603 case IBMVFC_HOST_ACTION_RESET:
4604 case IBMVFC_HOST_ACTION_REENABLE:
4605 default:
4606 break;
4607 }
4608
4609 return 1;
4610 }
4611
4612 /**
4613 * ibmvfc_work_to_do - Is there task level work to do?
4614 * @vhost: ibmvfc host struct
4615 *
4616 * Returns:
4617 * 1 if work to do / 0 if not
4618 **/
4619 static int ibmvfc_work_to_do(struct ibmvfc_host *vhost)
4620 {
4621 unsigned long flags;
4622 int rc;
4623
4624 spin_lock_irqsave(vhost->host->host_lock, flags);
4625 rc = __ibmvfc_work_to_do(vhost);
4626 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4627 return rc;
4628 }
4629
4630 /**
4631 * ibmvfc_log_ae - Log async events if necessary
4632 * @vhost: ibmvfc host struct
4633 * @events: events to log
4634 *
4635 **/
4636 static void ibmvfc_log_ae(struct ibmvfc_host *vhost, int events)
4637 {
4638 if (events & IBMVFC_AE_RSCN)
4639 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_RSCN, 0);
4640 if ((events & IBMVFC_AE_LINKDOWN) &&
4641 vhost->state >= IBMVFC_HALTED)
4642 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKDOWN, 0);
4643 if ((events & IBMVFC_AE_LINKUP) &&
4644 vhost->state == IBMVFC_INITIALIZING)
4645 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKUP, 0);
4646 }
4647
4648 /**
4649 * ibmvfc_tgt_add_rport - Tell the FC transport about a new remote port
4650 * @tgt: ibmvfc target struct
4651 *
4652 **/
4653 static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
4654 {
4655 struct ibmvfc_host *vhost = tgt->vhost;
4656 struct fc_rport *rport;
4657 unsigned long flags;
4658
4659 tgt_dbg(tgt, "Adding rport\n");
4660 rport = fc_remote_port_add(vhost->host, 0, &tgt->ids);
4661 spin_lock_irqsave(vhost->host->host_lock, flags);
4662
4663 if (rport && tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
4664 tgt_dbg(tgt, "Deleting rport\n");
4665 list_del(&tgt->queue);
4666 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
4667 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4668 fc_remote_port_delete(rport);
4669 del_timer_sync(&tgt->timer);
4670 kref_put(&tgt->kref, ibmvfc_release_tgt);
4671 return;
4672 } else if (rport && tgt->action == IBMVFC_TGT_ACTION_DEL_AND_LOGOUT_RPORT) {
4673 tgt_dbg(tgt, "Deleting rport with outstanding I/O\n");
4674 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT);
4675 tgt->rport = NULL;
4676 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4677 fc_remote_port_delete(rport);
4678 return;
4679 } else if (rport && tgt->action == IBMVFC_TGT_ACTION_DELETED_RPORT) {
4680 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4681 return;
4682 }
4683
4684 if (rport) {
4685 tgt_dbg(tgt, "rport add succeeded\n");
4686 tgt->rport = rport;
4687 rport->maxframe_size = be16_to_cpu(tgt->service_parms.common.bb_rcv_sz) & 0x0fff;
4688 rport->supported_classes = 0;
4689 tgt->target_id = rport->scsi_target_id;
4690 if (be32_to_cpu(tgt->service_parms.class1_parms[0]) & 0x80000000)
4691 rport->supported_classes |= FC_COS_CLASS1;
4692 if (be32_to_cpu(tgt->service_parms.class2_parms[0]) & 0x80000000)
4693 rport->supported_classes |= FC_COS_CLASS2;
4694 if (be32_to_cpu(tgt->service_parms.class3_parms[0]) & 0x80000000)
4695 rport->supported_classes |= FC_COS_CLASS3;
4696 if (rport->rqst_q)
4697 blk_queue_max_segments(rport->rqst_q, 1);
4698 } else
4699 tgt_dbg(tgt, "rport add failed\n");
4700 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4701 }
4702
4703 /**
4704 * ibmvfc_do_work - Do task level work
4705 * @vhost: ibmvfc host struct
4706 *
4707 **/
4708 static void ibmvfc_do_work(struct ibmvfc_host *vhost)
4709 {
4710 struct ibmvfc_target *tgt;
4711 unsigned long flags;
4712 struct fc_rport *rport;
4713 int rc;
4714
4715 ibmvfc_log_ae(vhost, vhost->events_to_log);
4716 spin_lock_irqsave(vhost->host->host_lock, flags);
4717 vhost->events_to_log = 0;
4718 switch (vhost->action) {
4719 case IBMVFC_HOST_ACTION_NONE:
4720 case IBMVFC_HOST_ACTION_LOGO_WAIT:
4721 case IBMVFC_HOST_ACTION_INIT_WAIT:
4722 break;
4723 case IBMVFC_HOST_ACTION_RESET:
4724 vhost->action = IBMVFC_HOST_ACTION_TGT_DEL;
4725 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4726 rc = ibmvfc_reset_crq(vhost);
4727 spin_lock_irqsave(vhost->host->host_lock, flags);
4728 if (rc == H_CLOSED)
4729 vio_enable_interrupts(to_vio_dev(vhost->dev));
4730 if (rc || (rc = ibmvfc_send_crq_init(vhost)) ||
4731 (rc = vio_enable_interrupts(to_vio_dev(vhost->dev)))) {
4732 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4733 dev_err(vhost->dev, "Error after reset (rc=%d)\n", rc);
4734 }
4735 break;
4736 case IBMVFC_HOST_ACTION_REENABLE:
4737 vhost->action = IBMVFC_HOST_ACTION_TGT_DEL;
4738 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4739 rc = ibmvfc_reenable_crq_queue(vhost);
4740 spin_lock_irqsave(vhost->host->host_lock, flags);
4741 if (rc || (rc = ibmvfc_send_crq_init(vhost))) {
4742 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
4743 dev_err(vhost->dev, "Error after enable (rc=%d)\n", rc);
4744 }
4745 break;
4746 case IBMVFC_HOST_ACTION_LOGO:
4747 vhost->job_step(vhost);
4748 break;
4749 case IBMVFC_HOST_ACTION_INIT:
4750 BUG_ON(vhost->state != IBMVFC_INITIALIZING);
4751 if (vhost->delay_init) {
4752 vhost->delay_init = 0;
4753 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4754 ssleep(15);
4755 return;
4756 } else
4757 vhost->job_step(vhost);
4758 break;
4759 case IBMVFC_HOST_ACTION_QUERY:
4760 list_for_each_entry(tgt, &vhost->targets, queue)
4761 ibmvfc_init_tgt(tgt, ibmvfc_tgt_query_target);
4762 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY_TGTS);
4763 break;
4764 case IBMVFC_HOST_ACTION_QUERY_TGTS:
4765 list_for_each_entry(tgt, &vhost->targets, queue) {
4766 if (tgt->action == IBMVFC_TGT_ACTION_INIT) {
4767 tgt->job_step(tgt);
4768 break;
4769 }
4770 }
4771
4772 if (!ibmvfc_dev_init_to_do(vhost))
4773 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
4774 break;
4775 case IBMVFC_HOST_ACTION_TGT_DEL:
4776 case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
4777 list_for_each_entry(tgt, &vhost->targets, queue) {
4778 if (tgt->action == IBMVFC_TGT_ACTION_LOGOUT_RPORT) {
4779 tgt->job_step(tgt);
4780 break;
4781 }
4782 }
4783
4784 if (ibmvfc_dev_logo_to_do(vhost)) {
4785 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4786 return;
4787 }
4788
4789 list_for_each_entry(tgt, &vhost->targets, queue) {
4790 if (tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
4791 tgt_dbg(tgt, "Deleting rport\n");
4792 rport = tgt->rport;
4793 tgt->rport = NULL;
4794 list_del(&tgt->queue);
4795 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
4796 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4797 if (rport)
4798 fc_remote_port_delete(rport);
4799 del_timer_sync(&tgt->timer);
4800 kref_put(&tgt->kref, ibmvfc_release_tgt);
4801 return;
4802 } else if (tgt->action == IBMVFC_TGT_ACTION_DEL_AND_LOGOUT_RPORT) {
4803 tgt_dbg(tgt, "Deleting rport with I/O outstanding\n");
4804 rport = tgt->rport;
4805 tgt->rport = NULL;
4806 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT);
4807 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4808 if (rport)
4809 fc_remote_port_delete(rport);
4810 return;
4811 }
4812 }
4813
4814 if (vhost->state == IBMVFC_INITIALIZING) {
4815 if (vhost->action == IBMVFC_HOST_ACTION_TGT_DEL_FAILED) {
4816 if (vhost->reinit) {
4817 vhost->reinit = 0;
4818 scsi_block_requests(vhost->host);
4819 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
4820 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4821 } else {
4822 ibmvfc_set_host_state(vhost, IBMVFC_ACTIVE);
4823 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
4824 wake_up(&vhost->init_wait_q);
4825 schedule_work(&vhost->rport_add_work_q);
4826 vhost->init_retries = 0;
4827 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4828 scsi_unblock_requests(vhost->host);
4829 }
4830
4831 return;
4832 } else {
4833 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
4834 vhost->job_step = ibmvfc_discover_targets;
4835 }
4836 } else {
4837 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
4838 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4839 scsi_unblock_requests(vhost->host);
4840 wake_up(&vhost->init_wait_q);
4841 return;
4842 }
4843 break;
4844 case IBMVFC_HOST_ACTION_ALLOC_TGTS:
4845 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_INIT);
4846 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4847 ibmvfc_alloc_targets(vhost);
4848 spin_lock_irqsave(vhost->host->host_lock, flags);
4849 break;
4850 case IBMVFC_HOST_ACTION_TGT_INIT:
4851 list_for_each_entry(tgt, &vhost->targets, queue) {
4852 if (tgt->action == IBMVFC_TGT_ACTION_INIT) {
4853 tgt->job_step(tgt);
4854 break;
4855 }
4856 }
4857
4858 if (!ibmvfc_dev_init_to_do(vhost))
4859 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL_FAILED);
4860 break;
4861 default:
4862 break;
4863 }
4864
4865 spin_unlock_irqrestore(vhost->host->host_lock, flags);
4866 }
4867
4868 /**
4869 * ibmvfc_work - Do task level work
4870 * @data: ibmvfc host struct
4871 *
4872 * Returns:
4873 * zero
4874 **/
4875 static int ibmvfc_work(void *data)
4876 {
4877 struct ibmvfc_host *vhost = data;
4878 int rc;
4879
4880 set_user_nice(current, MIN_NICE);
4881
4882 while (1) {
4883 rc = wait_event_interruptible(vhost->work_wait_q,
4884 ibmvfc_work_to_do(vhost));
4885
4886 BUG_ON(rc);
4887
4888 if (kthread_should_stop())
4889 break;
4890
4891 ibmvfc_do_work(vhost);
4892 }
4893
4894 ibmvfc_dbg(vhost, "ibmvfc kthread exiting...\n");
4895 return 0;
4896 }
4897
4898 /**
4899 * ibmvfc_init_crq - Initializes and registers CRQ with hypervisor
4900 * @vhost: ibmvfc host struct
4901 *
4902 * Allocates a page for messages, maps it for dma, and registers
4903 * the crq with the hypervisor.
4904 *
4905 * Return value:
4906 * zero on success / other on failure
4907 **/
4908 static int ibmvfc_init_crq(struct ibmvfc_host *vhost)
4909 {
4910 int rc, retrc = -ENOMEM;
4911 struct device *dev = vhost->dev;
4912 struct vio_dev *vdev = to_vio_dev(dev);
4913 struct ibmvfc_crq_queue *crq = &vhost->crq;
4914
4915 ENTER;
4916 crq->msgs = (struct ibmvfc_crq *)get_zeroed_page(GFP_KERNEL);
4917
4918 if (!crq->msgs)
4919 return -ENOMEM;
4920
4921 crq->size = PAGE_SIZE / sizeof(*crq->msgs);
4922 crq->msg_token = dma_map_single(dev, crq->msgs,
4923 PAGE_SIZE, DMA_BIDIRECTIONAL);
4924
4925 if (dma_mapping_error(dev, crq->msg_token))
4926 goto map_failed;
4927
4928 retrc = rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
4929 crq->msg_token, PAGE_SIZE);
4930
4931 if (rc == H_RESOURCE)
4932 /* maybe kexecing and resource is busy. try a reset */
4933 retrc = rc = ibmvfc_reset_crq(vhost);
4934
4935 if (rc == H_CLOSED)
4936 dev_warn(dev, "Partner adapter not ready\n");
4937 else if (rc) {
4938 dev_warn(dev, "Error %d opening adapter\n", rc);
4939 goto reg_crq_failed;
4940 }
4941
4942 retrc = 0;
4943
4944 tasklet_init(&vhost->tasklet, (void *)ibmvfc_tasklet, (unsigned long)vhost);
4945
4946 if ((rc = request_irq(vdev->irq, ibmvfc_interrupt, 0, IBMVFC_NAME, vhost))) {
4947 dev_err(dev, "Couldn't register irq 0x%x. rc=%d\n", vdev->irq, rc);
4948 goto req_irq_failed;
4949 }
4950
4951 if ((rc = vio_enable_interrupts(vdev))) {
4952 dev_err(dev, "Error %d enabling interrupts\n", rc);
4953 goto req_irq_failed;
4954 }
4955
4956 crq->cur = 0;
4957 LEAVE;
4958 return retrc;
4959
4960 req_irq_failed:
4961 tasklet_kill(&vhost->tasklet);
4962 do {
4963 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
4964 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
4965 reg_crq_failed:
4966 dma_unmap_single(dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
4967 map_failed:
4968 free_page((unsigned long)crq->msgs);
4969 return retrc;
4970 }
4971
4972 /**
4973 * ibmvfc_free_mem - Free memory for vhost
4974 * @vhost: ibmvfc host struct
4975 *
4976 * Return value:
4977 * none
4978 **/
4979 static void ibmvfc_free_mem(struct ibmvfc_host *vhost)
4980 {
4981 struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
4982
4983 ENTER;
4984 mempool_destroy(vhost->tgt_pool);
4985 kfree(vhost->trace);
4986 dma_free_coherent(vhost->dev, vhost->disc_buf_sz, vhost->disc_buf,
4987 vhost->disc_buf_dma);
4988 dma_free_coherent(vhost->dev, sizeof(*vhost->login_buf),
4989 vhost->login_buf, vhost->login_buf_dma);
4990 dma_pool_destroy(vhost->sg_pool);
4991 dma_unmap_single(vhost->dev, async_q->msg_token,
4992 async_q->size * sizeof(*async_q->msgs), DMA_BIDIRECTIONAL);
4993 free_page((unsigned long)async_q->msgs);
4994 LEAVE;
4995 }
4996
4997 /**
4998 * ibmvfc_alloc_mem - Allocate memory for vhost
4999 * @vhost: ibmvfc host struct
5000 *
5001 * Return value:
5002 * 0 on success / non-zero on failure
5003 **/
5004 static int ibmvfc_alloc_mem(struct ibmvfc_host *vhost)
5005 {
5006 struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
5007 struct device *dev = vhost->dev;
5008
5009 ENTER;
5010 async_q->msgs = (struct ibmvfc_async_crq *)get_zeroed_page(GFP_KERNEL);
5011 if (!async_q->msgs) {
5012 dev_err(dev, "Couldn't allocate async queue.\n");
5013 goto nomem;
5014 }
5015
5016 async_q->size = PAGE_SIZE / sizeof(struct ibmvfc_async_crq);
5017 async_q->msg_token = dma_map_single(dev, async_q->msgs,
5018 async_q->size * sizeof(*async_q->msgs),
5019 DMA_BIDIRECTIONAL);
5020
5021 if (dma_mapping_error(dev, async_q->msg_token)) {
5022 dev_err(dev, "Failed to map async queue\n");
5023 goto free_async_crq;
5024 }
5025
5026 vhost->sg_pool = dma_pool_create(IBMVFC_NAME, dev,
5027 SG_ALL * sizeof(struct srp_direct_buf),
5028 sizeof(struct srp_direct_buf), 0);
5029
5030 if (!vhost->sg_pool) {
5031 dev_err(dev, "Failed to allocate sg pool\n");
5032 goto unmap_async_crq;
5033 }
5034
5035 vhost->login_buf = dma_alloc_coherent(dev, sizeof(*vhost->login_buf),
5036 &vhost->login_buf_dma, GFP_KERNEL);
5037
5038 if (!vhost->login_buf) {
5039 dev_err(dev, "Couldn't allocate NPIV login buffer\n");
5040 goto free_sg_pool;
5041 }
5042
5043 vhost->disc_buf_sz = sizeof(*vhost->disc_buf) * max_targets;
5044 vhost->disc_buf = dma_alloc_coherent(dev, vhost->disc_buf_sz,
5045 &vhost->disc_buf_dma, GFP_KERNEL);
5046
5047 if (!vhost->disc_buf) {
5048 dev_err(dev, "Couldn't allocate Discover Targets buffer\n");
5049 goto free_login_buffer;
5050 }
5051
5052 vhost->trace = kcalloc(IBMVFC_NUM_TRACE_ENTRIES,
5053 sizeof(struct ibmvfc_trace_entry), GFP_KERNEL);
5054
5055 if (!vhost->trace)
5056 goto free_disc_buffer;
5057
5058 vhost->tgt_pool = mempool_create_kmalloc_pool(IBMVFC_TGT_MEMPOOL_SZ,
5059 sizeof(struct ibmvfc_target));
5060
5061 if (!vhost->tgt_pool) {
5062 dev_err(dev, "Couldn't allocate target memory pool\n");
5063 goto free_trace;
5064 }
5065
5066 LEAVE;
5067 return 0;
5068
5069 free_trace:
5070 kfree(vhost->trace);
5071 free_disc_buffer:
5072 dma_free_coherent(dev, vhost->disc_buf_sz, vhost->disc_buf,
5073 vhost->disc_buf_dma);
5074 free_login_buffer:
5075 dma_free_coherent(dev, sizeof(*vhost->login_buf),
5076 vhost->login_buf, vhost->login_buf_dma);
5077 free_sg_pool:
5078 dma_pool_destroy(vhost->sg_pool);
5079 unmap_async_crq:
5080 dma_unmap_single(dev, async_q->msg_token,
5081 async_q->size * sizeof(*async_q->msgs), DMA_BIDIRECTIONAL);
5082 free_async_crq:
5083 free_page((unsigned long)async_q->msgs);
5084 nomem:
5085 LEAVE;
5086 return -ENOMEM;
5087 }
5088
5089 /**
5090 * ibmvfc_rport_add_thread - Worker thread for rport adds
5091 * @work: work struct
5092 *
5093 **/
5094 static void ibmvfc_rport_add_thread(struct work_struct *work)
5095 {
5096 struct ibmvfc_host *vhost = container_of(work, struct ibmvfc_host,
5097 rport_add_work_q);
5098 struct ibmvfc_target *tgt;
5099 struct fc_rport *rport;
5100 unsigned long flags;
5101 int did_work;
5102
5103 ENTER;
5104 spin_lock_irqsave(vhost->host->host_lock, flags);
5105 do {
5106 did_work = 0;
5107 if (vhost->state != IBMVFC_ACTIVE)
5108 break;
5109
5110 list_for_each_entry(tgt, &vhost->targets, queue) {
5111 if (tgt->add_rport) {
5112 did_work = 1;
5113 tgt->add_rport = 0;
5114 kref_get(&tgt->kref);
5115 rport = tgt->rport;
5116 if (!rport) {
5117 spin_unlock_irqrestore(vhost->host->host_lock, flags);
5118 ibmvfc_tgt_add_rport(tgt);
5119 } else if (get_device(&rport->dev)) {
5120 spin_unlock_irqrestore(vhost->host->host_lock, flags);
5121 tgt_dbg(tgt, "Setting rport roles\n");
5122 fc_remote_port_rolechg(rport, tgt->ids.roles);
5123 put_device(&rport->dev);
5124 } else {
5125 spin_unlock_irqrestore(vhost->host->host_lock, flags);
5126 }
5127
5128 kref_put(&tgt->kref, ibmvfc_release_tgt);
5129 spin_lock_irqsave(vhost->host->host_lock, flags);
5130 break;
5131 }
5132 }
5133 } while(did_work);
5134
5135 if (vhost->state == IBMVFC_ACTIVE)
5136 vhost->scan_complete = 1;
5137 spin_unlock_irqrestore(vhost->host->host_lock, flags);
5138 LEAVE;
5139 }
5140
5141 /**
5142 * ibmvfc_probe - Adapter hot plug add entry point
5143 * @vdev: vio device struct
5144 * @id: vio device id struct
5145 *
5146 * Return value:
5147 * 0 on success / non-zero on failure
5148 **/
5149 static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
5150 {
5151 struct ibmvfc_host *vhost;
5152 struct Scsi_Host *shost;
5153 struct device *dev = &vdev->dev;
5154 int rc = -ENOMEM;
5155
5156 ENTER;
5157 shost = scsi_host_alloc(&driver_template, sizeof(*vhost));
5158 if (!shost) {
5159 dev_err(dev, "Couldn't allocate host data\n");
5160 goto out;
5161 }
5162
5163 shost->transportt = ibmvfc_transport_template;
5164 shost->can_queue = max_requests;
5165 shost->max_lun = max_lun;
5166 shost->max_id = max_targets;
5167 shost->max_sectors = IBMVFC_MAX_SECTORS;
5168 shost->max_cmd_len = IBMVFC_MAX_CDB_LEN;
5169 shost->unique_id = shost->host_no;
5170
5171 vhost = shost_priv(shost);
5172 INIT_LIST_HEAD(&vhost->sent);
5173 INIT_LIST_HEAD(&vhost->free);
5174 INIT_LIST_HEAD(&vhost->targets);
5175 sprintf(vhost->name, IBMVFC_NAME);
5176 vhost->host = shost;
5177 vhost->dev = dev;
5178 vhost->partition_number = -1;
5179 vhost->log_level = log_level;
5180 vhost->task_set = 1;
5181 strcpy(vhost->partition_name, "UNKNOWN");
5182 init_waitqueue_head(&vhost->work_wait_q);
5183 init_waitqueue_head(&vhost->init_wait_q);
5184 INIT_WORK(&vhost->rport_add_work_q, ibmvfc_rport_add_thread);
5185 mutex_init(&vhost->passthru_mutex);
5186
5187 if ((rc = ibmvfc_alloc_mem(vhost)))
5188 goto free_scsi_host;
5189
5190 vhost->work_thread = kthread_run(ibmvfc_work, vhost, "%s_%d", IBMVFC_NAME,
5191 shost->host_no);
5192
5193 if (IS_ERR(vhost->work_thread)) {
5194 dev_err(dev, "Couldn't create kernel thread: %ld\n",
5195 PTR_ERR(vhost->work_thread));
5196 rc = PTR_ERR(vhost->work_thread);
5197 goto free_host_mem;
5198 }
5199
5200 if ((rc = ibmvfc_init_crq(vhost))) {
5201 dev_err(dev, "Couldn't initialize crq. rc=%d\n", rc);
5202 goto kill_kthread;
5203 }
5204
5205 if ((rc = ibmvfc_init_event_pool(vhost))) {
5206 dev_err(dev, "Couldn't initialize event pool. rc=%d\n", rc);
5207 goto release_crq;
5208 }
5209
5210 if ((rc = scsi_add_host(shost, dev)))
5211 goto release_event_pool;
5212
5213 fc_host_dev_loss_tmo(shost) = IBMVFC_DEV_LOSS_TMO;
5214
5215 if ((rc = ibmvfc_create_trace_file(&shost->shost_dev.kobj,
5216 &ibmvfc_trace_attr))) {
5217 dev_err(dev, "Failed to create trace file. rc=%d\n", rc);
5218 goto remove_shost;
5219 }
5220
5221 if (shost_to_fc_host(shost)->rqst_q)
5222 blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);
5223 dev_set_drvdata(dev, vhost);
5224 spin_lock(&ibmvfc_driver_lock);
5225 list_add_tail(&vhost->queue, &ibmvfc_head);
5226 spin_unlock(&ibmvfc_driver_lock);
5227
5228 ibmvfc_send_crq_init(vhost);
5229 scsi_scan_host(shost);
5230 return 0;
5231
5232 remove_shost:
5233 scsi_remove_host(shost);
5234 release_event_pool:
5235 ibmvfc_free_event_pool(vhost);
5236 release_crq:
5237 ibmvfc_release_crq_queue(vhost);
5238 kill_kthread:
5239 kthread_stop(vhost->work_thread);
5240 free_host_mem:
5241 ibmvfc_free_mem(vhost);
5242 free_scsi_host:
5243 scsi_host_put(shost);
5244 out:
5245 LEAVE;
5246 return rc;
5247 }
5248
5249 /**
5250 * ibmvfc_remove - Adapter hot plug remove entry point
5251 * @vdev: vio device struct
5252 *
5253 * Return value:
5254 * 0
5255 **/
5256 static int ibmvfc_remove(struct vio_dev *vdev)
5257 {
5258 struct ibmvfc_host *vhost = dev_get_drvdata(&vdev->dev);
5259 unsigned long flags;
5260
5261 ENTER;
5262 ibmvfc_remove_trace_file(&vhost->host->shost_dev.kobj, &ibmvfc_trace_attr);
5263
5264 spin_lock_irqsave(vhost->host->host_lock, flags);
5265 ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
5266 spin_unlock_irqrestore(vhost->host->host_lock, flags);
5267
5268 ibmvfc_wait_while_resetting(vhost);
5269 ibmvfc_release_crq_queue(vhost);
5270 kthread_stop(vhost->work_thread);
5271 fc_remove_host(vhost->host);
5272 scsi_remove_host(vhost->host);
5273
5274 spin_lock_irqsave(vhost->host->host_lock, flags);
5275 ibmvfc_purge_requests(vhost, DID_ERROR);
5276 spin_unlock_irqrestore(vhost->host->host_lock, flags);
5277 ibmvfc_free_event_pool(vhost);
5278
5279 ibmvfc_free_mem(vhost);
5280 spin_lock(&ibmvfc_driver_lock);
5281 list_del(&vhost->queue);
5282 spin_unlock(&ibmvfc_driver_lock);
5283 scsi_host_put(vhost->host);
5284 LEAVE;
5285 return 0;
5286 }
5287
5288 /**
5289 * ibmvfc_resume - Resume from suspend
5290 * @dev: device struct
5291 *
5292 * We may have lost an interrupt across suspend/resume, so kick the
5293 * interrupt handler
5294 *
5295 */
5296 static int ibmvfc_resume(struct device *dev)
5297 {
5298 unsigned long flags;
5299 struct ibmvfc_host *vhost = dev_get_drvdata(dev);
5300 struct vio_dev *vdev = to_vio_dev(dev);
5301
5302 spin_lock_irqsave(vhost->host->host_lock, flags);
5303 vio_disable_interrupts(vdev);
5304 tasklet_schedule(&vhost->tasklet);
5305 spin_unlock_irqrestore(vhost->host->host_lock, flags);
5306 return 0;
5307 }
5308
5309 /**
5310 * ibmvfc_get_desired_dma - Calculate DMA resources needed by the driver
5311 * @vdev: vio device struct
5312 *
5313 * Return value:
5314 * Number of bytes the driver will need to DMA map at the same time in
5315 * order to perform well.
5316 */
5317 static unsigned long ibmvfc_get_desired_dma(struct vio_dev *vdev)
5318 {
5319 unsigned long pool_dma = max_requests * sizeof(union ibmvfc_iu);
5320 return pool_dma + ((512 * 1024) * driver_template.cmd_per_lun);
5321 }
5322
5323 static const struct vio_device_id ibmvfc_device_table[] = {
5324 {"fcp", "IBM,vfc-client"},
5325 { "", "" }
5326 };
5327 MODULE_DEVICE_TABLE(vio, ibmvfc_device_table);
5328
5329 static const struct dev_pm_ops ibmvfc_pm_ops = {
5330 .resume = ibmvfc_resume
5331 };
5332
5333 static struct vio_driver ibmvfc_driver = {
5334 .id_table = ibmvfc_device_table,
5335 .probe = ibmvfc_probe,
5336 .remove = ibmvfc_remove,
5337 .get_desired_dma = ibmvfc_get_desired_dma,
5338 .name = IBMVFC_NAME,
5339 .pm = &ibmvfc_pm_ops,
5340 };
5341
5342 static struct fc_function_template ibmvfc_transport_functions = {
5343 .show_host_fabric_name = 1,
5344 .show_host_node_name = 1,
5345 .show_host_port_name = 1,
5346 .show_host_supported_classes = 1,
5347 .show_host_port_type = 1,
5348 .show_host_port_id = 1,
5349 .show_host_maxframe_size = 1,
5350
5351 .get_host_port_state = ibmvfc_get_host_port_state,
5352 .show_host_port_state = 1,
5353
5354 .get_host_speed = ibmvfc_get_host_speed,
5355 .show_host_speed = 1,
5356
5357 .issue_fc_host_lip = ibmvfc_issue_fc_host_lip,
5358 .terminate_rport_io = ibmvfc_terminate_rport_io,
5359
5360 .show_rport_maxframe_size = 1,
5361 .show_rport_supported_classes = 1,
5362
5363 .set_rport_dev_loss_tmo = ibmvfc_set_rport_dev_loss_tmo,
5364 .show_rport_dev_loss_tmo = 1,
5365
5366 .get_starget_node_name = ibmvfc_get_starget_node_name,
5367 .show_starget_node_name = 1,
5368
5369 .get_starget_port_name = ibmvfc_get_starget_port_name,
5370 .show_starget_port_name = 1,
5371
5372 .get_starget_port_id = ibmvfc_get_starget_port_id,
5373 .show_starget_port_id = 1,
5374
5375 .bsg_request = ibmvfc_bsg_request,
5376 .bsg_timeout = ibmvfc_bsg_timeout,
5377 };
5378
5379 /**
5380 * ibmvfc_module_init - Initialize the ibmvfc module
5381 *
5382 * Return value:
5383 * 0 on success / other on failure
5384 **/
5385 static int __init ibmvfc_module_init(void)
5386 {
5387 int rc;
5388
5389 if (!firmware_has_feature(FW_FEATURE_VIO))
5390 return -ENODEV;
5391
5392 printk(KERN_INFO IBMVFC_NAME": IBM Virtual Fibre Channel Driver version: %s %s\n",
5393 IBMVFC_DRIVER_VERSION, IBMVFC_DRIVER_DATE);
5394
5395 ibmvfc_transport_template = fc_attach_transport(&ibmvfc_transport_functions);
5396 if (!ibmvfc_transport_template)
5397 return -ENOMEM;
5398
5399 rc = vio_register_driver(&ibmvfc_driver);
5400 if (rc)
5401 fc_release_transport(ibmvfc_transport_template);
5402 return rc;
5403 }
5404
5405 /**
5406 * ibmvfc_module_exit - Teardown the ibmvfc module
5407 *
5408 * Return value:
5409 * nothing
5410 **/
5411 static void __exit ibmvfc_module_exit(void)
5412 {
5413 vio_unregister_driver(&ibmvfc_driver);
5414 fc_release_transport(ibmvfc_transport_template);
5415 }
5416
5417 module_init(ibmvfc_module_init);
5418 module_exit(ibmvfc_module_exit);
Linux with added FPC-III support