drivers/scsi/ibmvscsi/ibmvfc.c

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