drivers/scsi/ibmvscsi/ibmvfc.c

   1 /*
   2  * ibmvfc.c -- driver for IBM Power Virtual Fibre Channel Adapter
   3  *
   4  * Written By: Brian King <brking@linux.vnet.ibm.com>, IBM Corporation
   5  *
   6  * Copyright (C) IBM Corporation, 2008
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/dmapool.h>
  28 #include <linux/delay.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/kthread.h>
  31 #include <linux/of.h>
  32 #include <linux/stringify.h>
  33 #include <asm/firmware.h>
  34 #include <asm/irq.h>
  35 #include <asm/vio.h>
  36 #include <scsi/scsi.h>
  37 #include <scsi/scsi_cmnd.h>
  38 #include <scsi/scsi_host.h>
  39 #include <scsi/scsi_device.h>
  40 #include <scsi/scsi_tcq.h>
  41 #include <scsi/scsi_transport_fc.h>
  42 #include "ibmvfc.h"
  43
  44 static unsigned int init_timeout = IBMVFC_INIT_TIMEOUT;
  45 static unsigned int default_timeout = IBMVFC_DEFAULT_TIMEOUT;
  46 static unsigned int max_lun = IBMVFC_MAX_LUN;
  47 static unsigned int max_targets = IBMVFC_MAX_TARGETS;
  48 static unsigned int max_requests = IBMVFC_MAX_REQUESTS_DEFAULT;
  49 static unsigned int disc_threads = IBMVFC_MAX_DISC_THREADS;
  50 static unsigned int dev_loss_tmo = IBMVFC_DEV_LOSS_TMO;
  51 static unsigned int ibmvfc_debug = IBMVFC_DEBUG;
  52 static unsigned int log_level = IBMVFC_DEFAULT_LOG_LEVEL;
  53 static LIST_HEAD(ibmvfc_head);
  54 static DEFINE_SPINLOCK(ibmvfc_driver_lock);
  55 static struct scsi_transport_template *ibmvfc_transport_template;
  56
  57 MODULE_DESCRIPTION("IBM Virtual Fibre Channel Driver");
  58 MODULE_AUTHOR("Brian King <brking@linux.vnet.ibm.com>");
  59 MODULE_LICENSE("GPL");
  60 MODULE_VERSION(IBMVFC_DRIVER_VERSION);
  61
  62 module_param_named(init_timeout, init_timeout, uint, S_IRUGO | S_IWUSR);
  63 MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds. "
  64                  "[Default=" __stringify(IBMVFC_INIT_TIMEOUT) "]");
  65 module_param_named(default_timeout, default_timeout, uint, S_IRUGO | S_IWUSR);
  66 MODULE_PARM_DESC(default_timeout,
  67                  "Default timeout in seconds for initialization and EH commands. "
  68                  "[Default=" __stringify(IBMVFC_DEFAULT_TIMEOUT) "]");
  69 module_param_named(max_requests, max_requests, uint, S_IRUGO);
  70 MODULE_PARM_DESC(max_requests, "Maximum requests for this adapter. "
  71                  "[Default=" __stringify(IBMVFC_MAX_REQUESTS_DEFAULT) "]");
  72 module_param_named(max_lun, max_lun, uint, S_IRUGO);
  73 MODULE_PARM_DESC(max_lun, "Maximum allowed LUN. "
  74                  "[Default=" __stringify(IBMVFC_MAX_LUN) "]");
  75 module_param_named(max_targets, max_targets, uint, S_IRUGO);
  76 MODULE_PARM_DESC(max_targets, "Maximum allowed targets. "
  77                  "[Default=" __stringify(IBMVFC_MAX_TARGETS) "]");
  78 module_param_named(disc_threads, disc_threads, uint, S_IRUGO | S_IWUSR);
  79 MODULE_PARM_DESC(disc_threads, "Number of device discovery threads to use. "
  80                  "[Default=" __stringify(IBMVFC_MAX_DISC_THREADS) "]");
  81 module_param_named(debug, ibmvfc_debug, uint, S_IRUGO | S_IWUSR);
  82 MODULE_PARM_DESC(debug, "Enable driver debug information. "
  83                  "[Default=" __stringify(IBMVFC_DEBUG) "]");
  84 module_param_named(dev_loss_tmo, dev_loss_tmo, uint, S_IRUGO | S_IWUSR);
  85 MODULE_PARM_DESC(dev_loss_tmo, "Maximum number of seconds that the FC "
  86                  "transport should insulate the loss of a remote port. Once this "
  87                  "value is exceeded, the scsi target is removed. "
  88                  "[Default=" __stringify(IBMVFC_DEV_LOSS_TMO) "]");
  89 module_param_named(log_level, log_level, uint, 0);
  90 MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver. "
  91                  "[Default=" __stringify(IBMVFC_DEFAULT_LOG_LEVEL) "]");
  92
  93 static const struct {
  94         u16 status;
  95         u16 error;
  96         u8 result;
  97         u8 retry;
  98         int log;
  99         char *name;
 100 } cmd_status [] = {
 101         { IBMVFC_FABRIC_MAPPED, IBMVFC_UNABLE_TO_ESTABLISH, DID_ERROR, 1, 1, "unable to establish" },
 102         { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_FAULT, DID_OK, 1, 0, "transport fault" },
 103         { IBMVFC_FABRIC_MAPPED, IBMVFC_CMD_TIMEOUT, DID_TIME_OUT, 1, 1, "command timeout" },
 104         { IBMVFC_FABRIC_MAPPED, IBMVFC_ENETDOWN, DID_TRANSPORT_DISRUPTED, 1, 1, "network down" },
 105         { IBMVFC_FABRIC_MAPPED, IBMVFC_HW_FAILURE, DID_ERROR, 1, 1, "hardware failure" },
 106         { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_DOWN_ERR, DID_REQUEUE, 0, 0, "link down" },
 107         { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_DEAD_ERR, DID_ERROR, 0, 0, "link dead" },
 108         { IBMVFC_FABRIC_MAPPED, IBMVFC_UNABLE_TO_REGISTER, DID_ERROR, 1, 1, "unable to register" },
 109         { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_BUSY, DID_BUS_BUSY, 1, 0, "transport busy" },
 110         { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_DEAD, DID_ERROR, 0, 1, "transport dead" },
 111         { IBMVFC_FABRIC_MAPPED, IBMVFC_CONFIG_ERROR, DID_ERROR, 1, 1, "configuration error" },
 112         { IBMVFC_FABRIC_MAPPED, IBMVFC_NAME_SERVER_FAIL, DID_ERROR, 1, 1, "name server failure" },
 113         { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_HALTED, DID_REQUEUE, 0, 0, "link halted" },
 114         { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_GENERAL, DID_OK, 1, 0, "general transport error" },
 115
 116         { IBMVFC_VIOS_FAILURE, IBMVFC_CRQ_FAILURE, DID_REQUEUE, 1, 1, "CRQ failure" },
 117         { IBMVFC_VIOS_FAILURE, IBMVFC_SW_FAILURE, DID_ERROR, 0, 1, "software failure" },
 118         { IBMVFC_VIOS_FAILURE, IBMVFC_INVALID_PARAMETER, DID_ERROR, 0, 1, "invalid parameter" },
 119         { IBMVFC_VIOS_FAILURE, IBMVFC_MISSING_PARAMETER, DID_ERROR, 0, 1, "missing parameter" },
 120         { IBMVFC_VIOS_FAILURE, IBMVFC_HOST_IO_BUS, DID_ERROR, 1, 1, "host I/O bus failure" },
 121         { IBMVFC_VIOS_FAILURE, IBMVFC_TRANS_CANCELLED, DID_ERROR, 0, 1, "transaction cancelled" },
 122         { IBMVFC_VIOS_FAILURE, IBMVFC_TRANS_CANCELLED_IMPLICIT, DID_ERROR, 0, 1, "transaction cancelled implicit" },
 123         { IBMVFC_VIOS_FAILURE, IBMVFC_INSUFFICIENT_RESOURCE, DID_REQUEUE, 1, 1, "insufficient resources" },
 124         { IBMVFC_VIOS_FAILURE, IBMVFC_PLOGI_REQUIRED, DID_ERROR, 0, 1, "port login required" },
 125         { IBMVFC_VIOS_FAILURE, IBMVFC_COMMAND_FAILED, DID_ERROR, 1, 1, "command failed" },
 126
 127         { IBMVFC_FC_FAILURE, IBMVFC_INVALID_ELS_CMD_CODE, DID_ERROR, 0, 1, "invalid ELS command code" },
 128         { IBMVFC_FC_FAILURE, IBMVFC_INVALID_VERSION, DID_ERROR, 0, 1, "invalid version level" },
 129         { IBMVFC_FC_FAILURE, IBMVFC_LOGICAL_ERROR, DID_ERROR, 1, 1, "logical error" },
 130         { IBMVFC_FC_FAILURE, IBMVFC_INVALID_CT_IU_SIZE, DID_ERROR, 0, 1, "invalid CT_IU size" },
 131         { IBMVFC_FC_FAILURE, IBMVFC_LOGICAL_BUSY, DID_REQUEUE, 1, 0, "logical busy" },
 132         { IBMVFC_FC_FAILURE, IBMVFC_PROTOCOL_ERROR, DID_ERROR, 1, 1, "protocol error" },
 133         { IBMVFC_FC_FAILURE, IBMVFC_UNABLE_TO_PERFORM_REQ, DID_ERROR, 1, 1, "unable to perform request" },
 134         { IBMVFC_FC_FAILURE, IBMVFC_CMD_NOT_SUPPORTED, DID_ERROR, 0, 0, "command not supported" },
 135         { IBMVFC_FC_FAILURE, IBMVFC_SERVER_NOT_AVAIL, DID_ERROR, 0, 1, "server not available" },
 136         { IBMVFC_FC_FAILURE, IBMVFC_CMD_IN_PROGRESS, DID_ERROR, 0, 1, "command already in progress" },
 137         { IBMVFC_FC_FAILURE, IBMVFC_VENDOR_SPECIFIC, DID_ERROR, 1, 1, "vendor specific" },
 138
 139         { IBMVFC_FC_SCSI_ERROR, 0, DID_OK, 1, 0, "SCSI error" },
 140 };
 141
 142 static void ibmvfc_npiv_login(struct ibmvfc_host *);
 143 static void ibmvfc_tgt_send_prli(struct ibmvfc_target *);
 144 static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *);
 145 static void ibmvfc_tgt_query_target(struct ibmvfc_target *);
 146
 147 static const char *unknown_error = "unknown error";
 148
 149 #ifdef CONFIG_SCSI_IBMVFC_TRACE
 150 /**
 151  * ibmvfc_trc_start - Log a start trace entry
 152  * @evt:                ibmvfc event struct
 153  *
 154  **/
 155 static void ibmvfc_trc_start(struct ibmvfc_event *evt)
 156 {
 157         struct ibmvfc_host *vhost = evt->vhost;
 158         struct ibmvfc_cmd *vfc_cmd = &evt->iu.cmd;
 159         struct ibmvfc_mad_common *mad = &evt->iu.mad_common;
 160         struct ibmvfc_trace_entry *entry;
 161
 162         entry = &vhost->trace[vhost->trace_index++];
 163         entry->evt = evt;
 164         entry->time = jiffies;
 165         entry->fmt = evt->crq.format;
 166         entry->type = IBMVFC_TRC_START;
 167
 168         switch (entry->fmt) {
 169         case IBMVFC_CMD_FORMAT:
 170                 entry->op_code = vfc_cmd->iu.cdb[0];
 171                 entry->scsi_id = vfc_cmd->tgt_scsi_id;
 172                 entry->lun = scsilun_to_int(&vfc_cmd->iu.lun);
 173                 entry->tmf_flags = vfc_cmd->iu.tmf_flags;
 174                 entry->u.start.xfer_len = vfc_cmd->iu.xfer_len;
 175                 break;
 176         case IBMVFC_MAD_FORMAT:
 177                 entry->op_code = mad->opcode;
 178                 break;
 179         default:
 180                 break;
 181         };
 182 }
 183
 184 /**
 185  * ibmvfc_trc_end - Log an end trace entry
 186  * @evt:                ibmvfc event struct
 187  *
 188  **/
 189 static void ibmvfc_trc_end(struct ibmvfc_event *evt)
 190 {
 191         struct ibmvfc_host *vhost = evt->vhost;
 192         struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
 193         struct ibmvfc_mad_common *mad = &evt->xfer_iu->mad_common;
 194         struct ibmvfc_trace_entry *entry = &vhost->trace[vhost->trace_index++];
 195
 196         entry->evt = evt;
 197         entry->time = jiffies;
 198         entry->fmt = evt->crq.format;
 199         entry->type = IBMVFC_TRC_END;
 200
 201         switch (entry->fmt) {
 202         case IBMVFC_CMD_FORMAT:
 203                 entry->op_code = vfc_cmd->iu.cdb[0];
 204                 entry->scsi_id = vfc_cmd->tgt_scsi_id;
 205                 entry->lun = scsilun_to_int(&vfc_cmd->iu.lun);
 206                 entry->tmf_flags = vfc_cmd->iu.tmf_flags;
 207                 entry->u.end.status = vfc_cmd->status;
 208                 entry->u.end.error = vfc_cmd->error;
 209                 entry->u.end.fcp_rsp_flags = vfc_cmd->rsp.flags;
 210                 entry->u.end.rsp_code = vfc_cmd->rsp.data.info.rsp_code;
 211                 entry->u.end.scsi_status = vfc_cmd->rsp.scsi_status;
 212                 break;
 213         case IBMVFC_MAD_FORMAT:
 214                 entry->op_code = mad->opcode;
 215                 entry->u.end.status = mad->status;
 216                 break;
 217         default:
 218                 break;
 219
 220         };
 221 }
 222
 223 #else
 224 #define ibmvfc_trc_start(evt) do { } while (0)
 225 #define ibmvfc_trc_end(evt) do { } while (0)
 226 #endif
 227
 228 /**
 229  * ibmvfc_get_err_index - Find the index into cmd_status for the fcp response
 230  * @status:             status / error class
 231  * @error:              error
 232  *
 233  * Return value:
 234  *      index into cmd_status / -EINVAL on failure
 235  **/
 236 static int ibmvfc_get_err_index(u16 status, u16 error)
 237 {
 238         int i;
 239
 240         for (i = 0; i < ARRAY_SIZE(cmd_status); i++)
 241                 if ((cmd_status[i].status & status) == cmd_status[i].status &&
 242                     cmd_status[i].error == error)
 243                         return i;
 244
 245         return -EINVAL;
 246 }
 247
 248 /**
 249  * ibmvfc_get_cmd_error - Find the error description for the fcp response
 250  * @status:             status / error class
 251  * @error:              error
 252  *
 253  * Return value:
 254  *      error description string
 255  **/
 256 static const char *ibmvfc_get_cmd_error(u16 status, u16 error)
 257 {
 258         int rc = ibmvfc_get_err_index(status, error);
 259         if (rc >= 0)
 260                 return cmd_status[rc].name;
 261         return unknown_error;
 262 }
 263
 264 /**
 265  * ibmvfc_get_err_result - Find the scsi status to return for the fcp response
 266  * @vfc_cmd:    ibmvfc command struct
 267  *
 268  * Return value:
 269  *      SCSI result value to return for completed command
 270  **/
 271 static int ibmvfc_get_err_result(struct ibmvfc_cmd *vfc_cmd)
 272 {
 273         int err;
 274         struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
 275         int fc_rsp_len = rsp->fcp_rsp_len;
 276
 277         if ((rsp->flags & FCP_RSP_LEN_VALID) &&
 278             ((!fc_rsp_len && fc_rsp_len != 4 && fc_rsp_len != 8) ||
 279              rsp->data.info.rsp_code))
 280                 return DID_ERROR << 16;
 281
 282         err = ibmvfc_get_err_index(vfc_cmd->status, vfc_cmd->error);
 283         if (err >= 0)
 284                 return rsp->scsi_status | (cmd_status[err].result << 16);
 285         return rsp->scsi_status | (DID_ERROR << 16);
 286 }
 287
 288 /**
 289  * ibmvfc_retry_cmd - Determine if error status is retryable
 290  * @status:             status / error class
 291  * @error:              error
 292  *
 293  * Return value:
 294  *      1 if error should be retried / 0 if it should not
 295  **/
 296 static int ibmvfc_retry_cmd(u16 status, u16 error)
 297 {
 298         int rc = ibmvfc_get_err_index(status, error);
 299
 300         if (rc >= 0)
 301                 return cmd_status[rc].retry;
 302         return 1;
 303 }
 304
 305 static const char *unknown_fc_explain = "unknown fc explain";
 306
 307 static const struct {
 308         u16 fc_explain;
 309         char *name;
 310 } ls_explain [] = {
 311         { 0x00, "no additional explanation" },
 312         { 0x01, "service parameter error - options" },
 313         { 0x03, "service parameter error - initiator control" },
 314         { 0x05, "service parameter error - recipient control" },
 315         { 0x07, "service parameter error - received data field size" },
 316         { 0x09, "service parameter error - concurrent seq" },
 317         { 0x0B, "service parameter error - credit" },
 318         { 0x0D, "invalid N_Port/F_Port_Name" },
 319         { 0x0E, "invalid node/Fabric Name" },
 320         { 0x0F, "invalid common service parameters" },
 321         { 0x11, "invalid association header" },
 322         { 0x13, "association header required" },
 323         { 0x15, "invalid originator S_ID" },
 324         { 0x17, "invalid OX_ID-RX-ID combination" },
 325         { 0x19, "command (request) already in progress" },
 326         { 0x1E, "N_Port Login requested" },
 327         { 0x1F, "Invalid N_Port_ID" },
 328 };
 329
 330 static const struct {
 331         u16 fc_explain;
 332         char *name;
 333 } gs_explain [] = {
 334         { 0x00, "no additional explanation" },
 335         { 0x01, "port identifier not registered" },
 336         { 0x02, "port name not registered" },
 337         { 0x03, "node name not registered" },
 338         { 0x04, "class of service not registered" },
 339         { 0x06, "initial process associator not registered" },
 340         { 0x07, "FC-4 TYPEs not registered" },
 341         { 0x08, "symbolic port name not registered" },
 342         { 0x09, "symbolic node name not registered" },
 343         { 0x0A, "port type not registered" },
 344         { 0xF0, "authorization exception" },
 345         { 0xF1, "authentication exception" },
 346         { 0xF2, "data base full" },
 347         { 0xF3, "data base empty" },
 348         { 0xF4, "processing request" },
 349         { 0xF5, "unable to verify connection" },
 350         { 0xF6, "devices not in a common zone" },
 351 };
 352
 353 /**
 354  * ibmvfc_get_ls_explain - Return the FC Explain description text
 355  * @status:     FC Explain status
 356  *
 357  * Returns:
 358  *      error string
 359  **/
 360 static const char *ibmvfc_get_ls_explain(u16 status)
 361 {
 362         int i;
 363
 364         for (i = 0; i < ARRAY_SIZE(ls_explain); i++)
 365                 if (ls_explain[i].fc_explain == status)
 366                         return ls_explain[i].name;
 367
 368         return unknown_fc_explain;
 369 }
 370
 371 /**
 372  * ibmvfc_get_gs_explain - Return the FC Explain description text
 373  * @status:     FC Explain status
 374  *
 375  * Returns:
 376  *      error string
 377  **/
 378 static const char *ibmvfc_get_gs_explain(u16 status)
 379 {
 380         int i;
 381
 382         for (i = 0; i < ARRAY_SIZE(gs_explain); i++)
 383                 if (gs_explain[i].fc_explain == status)
 384                         return gs_explain[i].name;
 385
 386         return unknown_fc_explain;
 387 }
 388
 389 static const struct {
 390         enum ibmvfc_fc_type fc_type;
 391         char *name;
 392 } fc_type [] = {
 393         { IBMVFC_FABRIC_REJECT, "fabric reject" },
 394         { IBMVFC_PORT_REJECT, "port reject" },
 395         { IBMVFC_LS_REJECT, "ELS reject" },
 396         { IBMVFC_FABRIC_BUSY, "fabric busy" },
 397         { IBMVFC_PORT_BUSY, "port busy" },
 398         { IBMVFC_BASIC_REJECT, "basic reject" },
 399 };
 400
 401 static const char *unknown_fc_type = "unknown fc type";
 402
 403 /**
 404  * ibmvfc_get_fc_type - Return the FC Type description text
 405  * @status:     FC Type error status
 406  *
 407  * Returns:
 408  *      error string
 409  **/
 410 static const char *ibmvfc_get_fc_type(u16 status)
 411 {
 412         int i;
 413
 414         for (i = 0; i < ARRAY_SIZE(fc_type); i++)
 415                 if (fc_type[i].fc_type == status)
 416                         return fc_type[i].name;
 417
 418         return unknown_fc_type;
 419 }
 420
 421 /**
 422  * ibmvfc_set_tgt_action - Set the next init action for the target
 423  * @tgt:                ibmvfc target struct
 424  * @action:             action to perform
 425  *
 426  **/
 427 static void ibmvfc_set_tgt_action(struct ibmvfc_target *tgt,
 428                                   enum ibmvfc_target_action action)
 429 {
 430         switch (tgt->action) {
 431         case IBMVFC_TGT_ACTION_DEL_RPORT:
 432                 break;
 433         default:
 434                 tgt->action = action;
 435                 break;
 436         }
 437 }
 438
 439 /**
 440  * ibmvfc_set_host_state - Set the state for the host
 441  * @vhost:              ibmvfc host struct
 442  * @state:              state to set host to
 443  *
 444  * Returns:
 445  *      0 if state changed / non-zero if not changed
 446  **/
 447 static int ibmvfc_set_host_state(struct ibmvfc_host *vhost,
 448                                   enum ibmvfc_host_state state)
 449 {
 450         int rc = 0;
 451
 452         switch (vhost->state) {
 453         case IBMVFC_HOST_OFFLINE:
 454                 rc = -EINVAL;
 455                 break;
 456         default:
 457                 vhost->state = state;
 458                 break;
 459         };
 460
 461         return rc;
 462 }
 463
 464 /**
 465  * ibmvfc_set_host_action - Set the next init action for the host
 466  * @vhost:              ibmvfc host struct
 467  * @action:             action to perform
 468  *
 469  **/
 470 static void ibmvfc_set_host_action(struct ibmvfc_host *vhost,
 471                                    enum ibmvfc_host_action action)
 472 {
 473         switch (action) {
 474         case IBMVFC_HOST_ACTION_ALLOC_TGTS:
 475                 if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT)
 476                         vhost->action = action;
 477                 break;
 478         case IBMVFC_HOST_ACTION_INIT_WAIT:
 479                 if (vhost->action == IBMVFC_HOST_ACTION_INIT)
 480                         vhost->action = action;
 481                 break;
 482         case IBMVFC_HOST_ACTION_QUERY:
 483                 switch (vhost->action) {
 484                 case IBMVFC_HOST_ACTION_INIT_WAIT:
 485                 case IBMVFC_HOST_ACTION_NONE:
 486                 case IBMVFC_HOST_ACTION_TGT_ADD:
 487                         vhost->action = action;
 488                         break;
 489                 default:
 490                         break;
 491                 };
 492                 break;
 493         case IBMVFC_HOST_ACTION_TGT_INIT:
 494                 if (vhost->action == IBMVFC_HOST_ACTION_ALLOC_TGTS)
 495                         vhost->action = action;
 496                 break;
 497         case IBMVFC_HOST_ACTION_INIT:
 498         case IBMVFC_HOST_ACTION_TGT_DEL:
 499         case IBMVFC_HOST_ACTION_QUERY_TGTS:
 500         case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
 501         case IBMVFC_HOST_ACTION_TGT_ADD:
 502         case IBMVFC_HOST_ACTION_NONE:
 503         default:
 504                 vhost->action = action;
 505                 break;
 506         };
 507 }
 508
 509 /**
 510  * ibmvfc_reinit_host - Re-start host initialization (no NPIV Login)
 511  * @vhost:              ibmvfc host struct
 512  *
 513  * Return value:
 514  *      nothing
 515  **/
 516 static void ibmvfc_reinit_host(struct ibmvfc_host *vhost)
 517 {
 518         if (vhost->action == IBMVFC_HOST_ACTION_NONE) {
 519                 if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
 520                         scsi_block_requests(vhost->host);
 521                         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
 522                 }
 523         } else
 524                 vhost->reinit = 1;
 525
 526         wake_up(&vhost->work_wait_q);
 527 }
 528
 529 /**
 530  * ibmvfc_link_down - Handle a link down event from the adapter
 531  * @vhost:      ibmvfc host struct
 532  * @state:      ibmvfc host state to enter
 533  *
 534  **/
 535 static void ibmvfc_link_down(struct ibmvfc_host *vhost,
 536                              enum ibmvfc_host_state state)
 537 {
 538         struct ibmvfc_target *tgt;
 539
 540         ENTER;
 541         scsi_block_requests(vhost->host);
 542         list_for_each_entry(tgt, &vhost->targets, queue)
 543                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
 544         ibmvfc_set_host_state(vhost, state);
 545         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
 546         vhost->events_to_log |= IBMVFC_AE_LINKDOWN;
 547         wake_up(&vhost->work_wait_q);
 548         LEAVE;
 549 }
 550
 551 /**
 552  * ibmvfc_init_host - Start host initialization
 553  * @vhost:              ibmvfc host struct
 554  * @relogin:    is this a re-login?
 555  *
 556  * Return value:
 557  *      nothing
 558  **/
 559 static void ibmvfc_init_host(struct ibmvfc_host *vhost, int relogin)
 560 {
 561         struct ibmvfc_target *tgt;
 562
 563         if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
 564                 if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
 565                         dev_err(vhost->dev,
 566                                 "Host initialization retries exceeded. Taking adapter offline\n");
 567                         ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
 568                         return;
 569                 }
 570         }
 571
 572         if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
 573                 if (!relogin) {
 574                         memset(vhost->async_crq.msgs, 0, PAGE_SIZE);
 575                         vhost->async_crq.cur = 0;
 576                 }
 577
 578                 list_for_each_entry(tgt, &vhost->targets, queue)
 579                         tgt->need_login = 1;
 580                 scsi_block_requests(vhost->host);
 581                 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
 582                 vhost->job_step = ibmvfc_npiv_login;
 583                 wake_up(&vhost->work_wait_q);
 584         }
 585 }
 586
 587 /**
 588  * ibmvfc_send_crq - Send a CRQ
 589  * @vhost:      ibmvfc host struct
 590  * @word1:      the first 64 bits of the data
 591  * @word2:      the second 64 bits of the data
 592  *
 593  * Return value:
 594  *      0 on success / other on failure
 595  **/
 596 static int ibmvfc_send_crq(struct ibmvfc_host *vhost, u64 word1, u64 word2)
 597 {
 598         struct vio_dev *vdev = to_vio_dev(vhost->dev);
 599         return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
 600 }
 601
 602 /**
 603  * ibmvfc_send_crq_init - Send a CRQ init message
 604  * @vhost:      ibmvfc host struct
 605  *
 606  * Return value:
 607  *      0 on success / other on failure
 608  **/
 609 static int ibmvfc_send_crq_init(struct ibmvfc_host *vhost)
 610 {
 611         ibmvfc_dbg(vhost, "Sending CRQ init\n");
 612         return ibmvfc_send_crq(vhost, 0xC001000000000000LL, 0);
 613 }
 614
 615 /**
 616  * ibmvfc_send_crq_init_complete - Send a CRQ init complete message
 617  * @vhost:      ibmvfc host struct
 618  *
 619  * Return value:
 620  *      0 on success / other on failure
 621  **/
 622 static int ibmvfc_send_crq_init_complete(struct ibmvfc_host *vhost)
 623 {
 624         ibmvfc_dbg(vhost, "Sending CRQ init complete\n");
 625         return ibmvfc_send_crq(vhost, 0xC002000000000000LL, 0);
 626 }
 627
 628 /**
 629  * ibmvfc_release_crq_queue - Deallocates data and unregisters CRQ
 630  * @vhost:      ibmvfc host struct
 631  *
 632  * Frees irq, deallocates a page for messages, unmaps dma, and unregisters
 633  * the crq with the hypervisor.
 634  **/
 635 static void ibmvfc_release_crq_queue(struct ibmvfc_host *vhost)
 636 {
 637         long rc;
 638         struct vio_dev *vdev = to_vio_dev(vhost->dev);
 639         struct ibmvfc_crq_queue *crq = &vhost->crq;
 640
 641         ibmvfc_dbg(vhost, "Releasing CRQ\n");
 642         free_irq(vdev->irq, vhost);
 643         do {
 644                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
 645         } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
 646
 647         vhost->state = IBMVFC_NO_CRQ;
 648         dma_unmap_single(vhost->dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
 649         free_page((unsigned long)crq->msgs);
 650 }
 651
 652 /**
 653  * ibmvfc_reenable_crq_queue - reenables the CRQ
 654  * @vhost:      ibmvfc host struct
 655  *
 656  * Return value:
 657  *      0 on success / other on failure
 658  **/
 659 static int ibmvfc_reenable_crq_queue(struct ibmvfc_host *vhost)
 660 {
 661         int rc;
 662         struct vio_dev *vdev = to_vio_dev(vhost->dev);
 663
 664         /* Re-enable the CRQ */
 665         do {
 666                 rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
 667         } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc));
 668
 669         if (rc)
 670                 dev_err(vhost->dev, "Error enabling adapter (rc=%d)\n", rc);
 671
 672         return rc;
 673 }
 674
 675 /**
 676  * ibmvfc_reset_crq - resets a crq after a failure
 677  * @vhost:      ibmvfc host struct
 678  *
 679  * Return value:
 680  *      0 on success / other on failure
 681  **/
 682 static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)
 683 {
 684         int rc;
 685         struct vio_dev *vdev = to_vio_dev(vhost->dev);
 686         struct ibmvfc_crq_queue *crq = &vhost->crq;
 687
 688         /* Close the CRQ */
 689         do {
 690                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
 691         } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
 692
 693         vhost->state = IBMVFC_NO_CRQ;
 694         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
 695
 696         /* Clean out the queue */
 697         memset(crq->msgs, 0, PAGE_SIZE);
 698         crq->cur = 0;
 699
 700         /* And re-open it again */
 701         rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
 702                                 crq->msg_token, PAGE_SIZE);
 703
 704         if (rc == H_CLOSED)
 705                 /* Adapter is good, but other end is not ready */
 706                 dev_warn(vhost->dev, "Partner adapter not ready\n");
 707         else if (rc != 0)
 708                 dev_warn(vhost->dev, "Couldn't register crq (rc=%d)\n", rc);
 709
 710         return rc;
 711 }
 712
 713 /**
 714  * ibmvfc_valid_event - Determines if event is valid.
 715  * @pool:       event_pool that contains the event
 716  * @evt:        ibmvfc event to be checked for validity
 717  *
 718  * Return value:
 719  *      1 if event is valid / 0 if event is not valid
 720  **/
 721 static int ibmvfc_valid_event(struct ibmvfc_event_pool *pool,
 722                               struct ibmvfc_event *evt)
 723 {
 724         int index = evt - pool->events;
 725         if (index < 0 || index >= pool->size)   /* outside of bounds */
 726                 return 0;
 727         if (evt != pool->events + index)        /* unaligned */
 728                 return 0;
 729         return 1;
 730 }
 731
 732 /**
 733  * ibmvfc_free_event - Free the specified event
 734  * @evt:        ibmvfc_event to be freed
 735  *
 736  **/
 737 static void ibmvfc_free_event(struct ibmvfc_event *evt)
 738 {
 739         struct ibmvfc_host *vhost = evt->vhost;
 740         struct ibmvfc_event_pool *pool = &vhost->pool;
 741
 742         BUG_ON(!ibmvfc_valid_event(pool, evt));
 743         BUG_ON(atomic_inc_return(&evt->free) != 1);
 744         list_add_tail(&evt->queue, &vhost->free);
 745 }
 746
 747 /**
 748  * ibmvfc_scsi_eh_done - EH done function for queuecommand commands
 749  * @evt:        ibmvfc event struct
 750  *
 751  * This function does not setup any error status, that must be done
 752  * before this function gets called.
 753  **/
 754 static void ibmvfc_scsi_eh_done(struct ibmvfc_event *evt)
 755 {
 756         struct scsi_cmnd *cmnd = evt->cmnd;
 757
 758         if (cmnd) {
 759                 scsi_dma_unmap(cmnd);
 760                 cmnd->scsi_done(cmnd);
 761         }
 762
 763         if (evt->eh_comp)
 764                 complete(evt->eh_comp);
 765
 766         ibmvfc_free_event(evt);
 767 }
 768
 769 /**
 770  * ibmvfc_fail_request - Fail request with specified error code
 771  * @evt:                ibmvfc event struct
 772  * @error_code: error code to fail request with
 773  *
 774  * Return value:
 775  *      none
 776  **/
 777 static void ibmvfc_fail_request(struct ibmvfc_event *evt, int error_code)
 778 {
 779         if (evt->cmnd) {
 780                 evt->cmnd->result = (error_code << 16);
 781                 evt->done = ibmvfc_scsi_eh_done;
 782         } else
 783                 evt->xfer_iu->mad_common.status = IBMVFC_MAD_DRIVER_FAILED;
 784
 785         list_del(&evt->queue);
 786         del_timer(&evt->timer);
 787         ibmvfc_trc_end(evt);
 788         evt->done(evt);
 789 }
 790
 791 /**
 792  * ibmvfc_purge_requests - Our virtual adapter just shut down. Purge any sent requests
 793  * @vhost:              ibmvfc host struct
 794  * @error_code: error code to fail requests with
 795  *
 796  * Return value:
 797  *      none
 798  **/
 799 static void ibmvfc_purge_requests(struct ibmvfc_host *vhost, int error_code)
 800 {
 801         struct ibmvfc_event *evt, *pos;
 802
 803         ibmvfc_dbg(vhost, "Purging all requests\n");
 804         list_for_each_entry_safe(evt, pos, &vhost->sent, queue)
 805                 ibmvfc_fail_request(evt, error_code);
 806 }
 807
 808 /**
 809  * __ibmvfc_reset_host - Reset the connection to the server (no locking)
 810  * @vhost:      struct ibmvfc host to reset
 811  **/
 812 static void __ibmvfc_reset_host(struct ibmvfc_host *vhost)
 813 {
 814         int rc;
 815
 816         scsi_block_requests(vhost->host);
 817         ibmvfc_purge_requests(vhost, DID_ERROR);
 818         if ((rc = ibmvfc_reset_crq(vhost)) ||
 819             (rc = ibmvfc_send_crq_init(vhost)) ||
 820             (rc = vio_enable_interrupts(to_vio_dev(vhost->dev)))) {
 821                 dev_err(vhost->dev, "Error after reset rc=%d\n", rc);
 822                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
 823         } else
 824                 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
 825 }
 826
 827 /**
 828  * ibmvfc_reset_host - Reset the connection to the server
 829  * @vhost:      struct ibmvfc host to reset
 830  **/
 831 static void ibmvfc_reset_host(struct ibmvfc_host *vhost)
 832 {
 833         unsigned long flags;
 834
 835         spin_lock_irqsave(vhost->host->host_lock, flags);
 836         __ibmvfc_reset_host(vhost);
 837         spin_unlock_irqrestore(vhost->host->host_lock, flags);
 838 }
 839
 840 /**
 841  * ibmvfc_retry_host_init - Retry host initialization if allowed
 842  * @vhost:      ibmvfc host struct
 843  *
 844  **/
 845 static void ibmvfc_retry_host_init(struct ibmvfc_host *vhost)
 846 {
 847         if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
 848                 vhost->delay_init = 1;
 849                 if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
 850                         dev_err(vhost->dev,
 851                                 "Host initialization retries exceeded. Taking adapter offline\n");
 852                         ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
 853                 } else if (vhost->init_retries == IBMVFC_MAX_HOST_INIT_RETRIES)
 854                         __ibmvfc_reset_host(vhost);
 855                 else
 856                         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
 857         }
 858
 859         wake_up(&vhost->work_wait_q);
 860 }
 861
 862 /**
 863  * __ibmvfc_get_target - Find the specified scsi_target (no locking)
 864  * @starget:    scsi target struct
 865  *
 866  * Return value:
 867  *      ibmvfc_target struct / NULL if not found
 868  **/
 869 static struct ibmvfc_target *__ibmvfc_get_target(struct scsi_target *starget)
 870 {
 871         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 872         struct ibmvfc_host *vhost = shost_priv(shost);
 873         struct ibmvfc_target *tgt;
 874
 875         list_for_each_entry(tgt, &vhost->targets, queue)
 876                 if (tgt->target_id == starget->id) {
 877                         kref_get(&tgt->kref);
 878                         return tgt;
 879                 }
 880         return NULL;
 881 }
 882
 883 /**
 884  * ibmvfc_get_target - Find the specified scsi_target
 885  * @starget:    scsi target struct
 886  *
 887  * Return value:
 888  *      ibmvfc_target struct / NULL if not found
 889  **/
 890 static struct ibmvfc_target *ibmvfc_get_target(struct scsi_target *starget)
 891 {
 892         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 893         struct ibmvfc_target *tgt;
 894         unsigned long flags;
 895
 896         spin_lock_irqsave(shost->host_lock, flags);
 897         tgt = __ibmvfc_get_target(starget);
 898         spin_unlock_irqrestore(shost->host_lock, flags);
 899         return tgt;
 900 }
 901
 902 /**
 903  * ibmvfc_get_host_speed - Get host port speed
 904  * @shost:              scsi host struct
 905  *
 906  * Return value:
 907  *      none
 908  **/
 909 static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
 910 {
 911         struct ibmvfc_host *vhost = shost_priv(shost);
 912         unsigned long flags;
 913
 914         spin_lock_irqsave(shost->host_lock, flags);
 915         if (vhost->state == IBMVFC_ACTIVE) {
 916                 switch (vhost->login_buf->resp.link_speed / 100) {
 917                 case 1:
 918                         fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
 919                         break;
 920                 case 2:
 921                         fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
 922                         break;
 923                 case 4:
 924                         fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
 925                         break;
 926                 case 8:
 927                         fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
 928                         break;
 929                 case 10:
 930                         fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
 931                         break;
 932                 case 16:
 933                         fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
 934                         break;
 935                 default:
 936                         ibmvfc_log(vhost, 3, "Unknown port speed: %lld Gbit\n",
 937                                    vhost->login_buf->resp.link_speed / 100);
 938                         fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
 939                         break;
 940                 }
 941         } else
 942                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
 943         spin_unlock_irqrestore(shost->host_lock, flags);
 944 }
 945
 946 /**
 947  * ibmvfc_get_host_port_state - Get host port state
 948  * @shost:              scsi host struct
 949  *
 950  * Return value:
 951  *      none
 952  **/
 953 static void ibmvfc_get_host_port_state(struct Scsi_Host *shost)
 954 {
 955         struct ibmvfc_host *vhost = shost_priv(shost);
 956         unsigned long flags;
 957
 958         spin_lock_irqsave(shost->host_lock, flags);
 959         switch (vhost->state) {
 960         case IBMVFC_INITIALIZING:
 961         case IBMVFC_ACTIVE:
 962                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
 963                 break;
 964         case IBMVFC_LINK_DOWN:
 965                 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
 966                 break;
 967         case IBMVFC_LINK_DEAD:
 968         case IBMVFC_HOST_OFFLINE:
 969                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
 970                 break;
 971         case IBMVFC_HALTED:
 972                 fc_host_port_state(shost) = FC_PORTSTATE_BLOCKED;
 973                 break;
 974         case IBMVFC_NO_CRQ:
 975                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
 976                 break;
 977         default:
 978                 ibmvfc_log(vhost, 3, "Unknown port state: %d\n", vhost->state);
 979                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
 980                 break;
 981         }
 982         spin_unlock_irqrestore(shost->host_lock, flags);
 983 }
 984
 985 /**
 986  * ibmvfc_set_rport_dev_loss_tmo - Set rport's device loss timeout
 987  * @rport:              rport struct
 988  * @timeout:    timeout value
 989  *
 990  * Return value:
 991  *      none
 992  **/
 993 static void ibmvfc_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
 994 {
 995         if (timeout)
 996                 rport->dev_loss_tmo = timeout;
 997         else
 998                 rport->dev_loss_tmo = 1;
 999 }
1000
1001 /**
1002  * ibmvfc_release_tgt - Free memory allocated for a target
1003  * @kref:               kref struct
1004  *
1005  **/
1006 static void ibmvfc_release_tgt(struct kref *kref)
1007 {
1008         struct ibmvfc_target *tgt = container_of(kref, struct ibmvfc_target, kref);
1009         kfree(tgt);
1010 }
1011
1012 /**
1013  * ibmvfc_get_starget_node_name - Get SCSI target's node name
1014  * @starget:    scsi target struct
1015  *
1016  * Return value:
1017  *      none
1018  **/
1019 static void ibmvfc_get_starget_node_name(struct scsi_target *starget)
1020 {
1021         struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
1022         fc_starget_port_name(starget) = tgt ? tgt->ids.node_name : 0;
1023         if (tgt)
1024                 kref_put(&tgt->kref, ibmvfc_release_tgt);
1025 }
1026
1027 /**
1028  * ibmvfc_get_starget_port_name - Get SCSI target's port name
1029  * @starget:    scsi target struct
1030  *
1031  * Return value:
1032  *      none
1033  **/
1034 static void ibmvfc_get_starget_port_name(struct scsi_target *starget)
1035 {
1036         struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
1037         fc_starget_port_name(starget) = tgt ? tgt->ids.port_name : 0;
1038         if (tgt)
1039                 kref_put(&tgt->kref, ibmvfc_release_tgt);
1040 }
1041
1042 /**
1043  * ibmvfc_get_starget_port_id - Get SCSI target's port ID
1044  * @starget:    scsi target struct
1045  *
1046  * Return value:
1047  *      none
1048  **/
1049 static void ibmvfc_get_starget_port_id(struct scsi_target *starget)
1050 {
1051         struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
1052         fc_starget_port_id(starget) = tgt ? tgt->scsi_id : -1;
1053         if (tgt)
1054                 kref_put(&tgt->kref, ibmvfc_release_tgt);
1055 }
1056
1057 /**
1058  * ibmvfc_wait_while_resetting - Wait while the host resets
1059  * @vhost:              ibmvfc host struct
1060  *
1061  * Return value:
1062  *      0 on success / other on failure
1063  **/
1064 static int ibmvfc_wait_while_resetting(struct ibmvfc_host *vhost)
1065 {
1066         long timeout = wait_event_timeout(vhost->init_wait_q,
1067                                           ((vhost->state == IBMVFC_ACTIVE ||
1068                                             vhost->state == IBMVFC_HOST_OFFLINE ||
1069                                             vhost->state == IBMVFC_LINK_DEAD) &&
1070                                            vhost->action == IBMVFC_HOST_ACTION_NONE),
1071                                           (init_timeout * HZ));
1072
1073         return timeout ? 0 : -EIO;
1074 }
1075
1076 /**
1077  * ibmvfc_issue_fc_host_lip - Re-initiate link initialization
1078  * @shost:              scsi host struct
1079  *
1080  * Return value:
1081  *      0 on success / other on failure
1082  **/
1083 static int ibmvfc_issue_fc_host_lip(struct Scsi_Host *shost)
1084 {
1085         struct ibmvfc_host *vhost = shost_priv(shost);
1086
1087         dev_err(vhost->dev, "Initiating host LIP. Resetting connection\n");
1088         ibmvfc_reset_host(vhost);
1089         return ibmvfc_wait_while_resetting(vhost);
1090 }
1091
1092 /**
1093  * ibmvfc_gather_partition_info - Gather info about the LPAR
1094  *
1095  * Return value:
1096  *      none
1097  **/
1098 static void ibmvfc_gather_partition_info(struct ibmvfc_host *vhost)
1099 {
1100         struct device_node *rootdn;
1101         const char *name;
1102         const unsigned int *num;
1103
1104         rootdn = of_find_node_by_path("/");
1105         if (!rootdn)
1106                 return;
1107
1108         name = of_get_property(rootdn, "ibm,partition-name", NULL);
1109         if (name)
1110                 strncpy(vhost->partition_name, name, sizeof(vhost->partition_name));
1111         num = of_get_property(rootdn, "ibm,partition-no", NULL);
1112         if (num)
1113                 vhost->partition_number = *num;
1114         of_node_put(rootdn);
1115 }
1116
1117 /**
1118  * ibmvfc_set_login_info - Setup info for NPIV login
1119  * @vhost:      ibmvfc host struct
1120  *
1121  * Return value:
1122  *      none
1123  **/
1124 static void ibmvfc_set_login_info(struct ibmvfc_host *vhost)
1125 {
1126         struct ibmvfc_npiv_login *login_info = &vhost->login_info;
1127         struct device_node *of_node = vhost->dev->archdata.of_node;
1128         const char *location;
1129
1130         memset(login_info, 0, sizeof(*login_info));
1131
1132         login_info->ostype = IBMVFC_OS_LINUX;
1133         login_info->max_dma_len = IBMVFC_MAX_SECTORS << 9;
1134         login_info->max_payload = sizeof(struct ibmvfc_fcp_cmd_iu);
1135         login_info->max_response = sizeof(struct ibmvfc_fcp_rsp);
1136         login_info->partition_num = vhost->partition_number;
1137         login_info->vfc_frame_version = 1;
1138         login_info->fcp_version = 3;
1139         if (vhost->client_migrated)
1140                 login_info->flags = IBMVFC_CLIENT_MIGRATED;
1141
1142         login_info->max_cmds = max_requests + IBMVFC_NUM_INTERNAL_REQ;
1143         login_info->capabilities = IBMVFC_CAN_MIGRATE;
1144         login_info->async.va = vhost->async_crq.msg_token;
1145         login_info->async.len = vhost->async_crq.size * sizeof(*vhost->async_crq.msgs);
1146         strncpy(login_info->partition_name, vhost->partition_name, IBMVFC_MAX_NAME);
1147         strncpy(login_info->device_name,
1148                 dev_name(&vhost->host->shost_gendev), IBMVFC_MAX_NAME);
1149
1150         location = of_get_property(of_node, "ibm,loc-code", NULL);
1151         location = location ? location : dev_name(vhost->dev);
1152         strncpy(login_info->drc_name, location, IBMVFC_MAX_NAME);
1153 }
1154
1155 /**
1156  * ibmvfc_init_event_pool - Allocates and initializes the event pool for a host
1157  * @vhost:      ibmvfc host who owns the event pool
1158  *
1159  * Returns zero on success.
1160  **/
1161 static int ibmvfc_init_event_pool(struct ibmvfc_host *vhost)
1162 {
1163         int i;
1164         struct ibmvfc_event_pool *pool = &vhost->pool;
1165
1166         ENTER;
1167         pool->size = max_requests + IBMVFC_NUM_INTERNAL_REQ;
1168         pool->events = kcalloc(pool->size, sizeof(*pool->events), GFP_KERNEL);
1169         if (!pool->events)
1170                 return -ENOMEM;
1171
1172         pool->iu_storage = dma_alloc_coherent(vhost->dev,
1173                                               pool->size * sizeof(*pool->iu_storage),
1174                                               &pool->iu_token, 0);
1175
1176         if (!pool->iu_storage) {
1177                 kfree(pool->events);
1178                 return -ENOMEM;
1179         }
1180
1181         for (i = 0; i < pool->size; ++i) {
1182                 struct ibmvfc_event *evt = &pool->events[i];
1183                 atomic_set(&evt->free, 1);
1184                 evt->crq.valid = 0x80;
1185                 evt->crq.ioba = pool->iu_token + (sizeof(*evt->xfer_iu) * i);
1186                 evt->xfer_iu = pool->iu_storage + i;
1187                 evt->vhost = vhost;
1188                 evt->ext_list = NULL;
1189                 list_add_tail(&evt->queue, &vhost->free);
1190         }
1191
1192         LEAVE;
1193         return 0;
1194 }
1195
1196 /**
1197  * ibmvfc_free_event_pool - Frees memory of the event pool of a host
1198  * @vhost:      ibmvfc host who owns the event pool
1199  *
1200  **/
1201 static void ibmvfc_free_event_pool(struct ibmvfc_host *vhost)
1202 {
1203         int i;
1204         struct ibmvfc_event_pool *pool = &vhost->pool;
1205
1206         ENTER;
1207         for (i = 0; i < pool->size; ++i) {
1208                 list_del(&pool->events[i].queue);
1209                 BUG_ON(atomic_read(&pool->events[i].free) != 1);
1210                 if (pool->events[i].ext_list)
1211                         dma_pool_free(vhost->sg_pool,
1212                                       pool->events[i].ext_list,
1213                                       pool->events[i].ext_list_token);
1214         }
1215
1216         kfree(pool->events);
1217         dma_free_coherent(vhost->dev,
1218                           pool->size * sizeof(*pool->iu_storage),
1219                           pool->iu_storage, pool->iu_token);
1220         LEAVE;
1221 }
1222
1223 /**
1224  * ibmvfc_get_event - Gets the next free event in pool
1225  * @vhost:      ibmvfc host struct
1226  *
1227  * Returns a free event from the pool.
1228  **/
1229 static struct ibmvfc_event *ibmvfc_get_event(struct ibmvfc_host *vhost)
1230 {
1231         struct ibmvfc_event *evt;
1232
1233         BUG_ON(list_empty(&vhost->free));
1234         evt = list_entry(vhost->free.next, struct ibmvfc_event, queue);
1235         atomic_set(&evt->free, 0);
1236         list_del(&evt->queue);
1237         return evt;
1238 }
1239
1240 /**
1241  * ibmvfc_init_event - Initialize fields in an event struct that are always
1242  *                              required.
1243  * @evt:        The event
1244  * @done:       Routine to call when the event is responded to
1245  * @format:     SRP or MAD format
1246  **/
1247 static void ibmvfc_init_event(struct ibmvfc_event *evt,
1248                               void (*done) (struct ibmvfc_event *), u8 format)
1249 {
1250         evt->cmnd = NULL;
1251         evt->sync_iu = NULL;
1252         evt->crq.format = format;
1253         evt->done = done;
1254         evt->eh_comp = NULL;
1255 }
1256
1257 /**
1258  * ibmvfc_map_sg_list - Initialize scatterlist
1259  * @scmd:       scsi command struct
1260  * @nseg:       number of scatterlist segments
1261  * @md: memory descriptor list to initialize
1262  **/
1263 static void ibmvfc_map_sg_list(struct scsi_cmnd *scmd, int nseg,
1264                                struct srp_direct_buf *md)
1265 {
1266         int i;
1267         struct scatterlist *sg;
1268
1269         scsi_for_each_sg(scmd, sg, nseg, i) {
1270                 md[i].va = sg_dma_address(sg);
1271                 md[i].len = sg_dma_len(sg);
1272                 md[i].key = 0;
1273         }
1274 }
1275
1276 /**
1277  * ibmvfc_map_sg_data - Maps dma for a scatterlist and initializes decriptor fields
1278  * @scmd:               Scsi_Cmnd with the scatterlist
1279  * @evt:                ibmvfc event struct
1280  * @vfc_cmd:    vfc_cmd that contains the memory descriptor
1281  * @dev:                device for which to map dma memory
1282  *
1283  * Returns:
1284  *      0 on success / non-zero on failure
1285  **/
1286 static int ibmvfc_map_sg_data(struct scsi_cmnd *scmd,
1287                               struct ibmvfc_event *evt,
1288                               struct ibmvfc_cmd *vfc_cmd, struct device *dev)
1289 {
1290
1291         int sg_mapped;
1292         struct srp_direct_buf *data = &vfc_cmd->ioba;
1293         struct ibmvfc_host *vhost = dev_get_drvdata(dev);
1294
1295         sg_mapped = scsi_dma_map(scmd);
1296         if (!sg_mapped) {
1297                 vfc_cmd->flags |= IBMVFC_NO_MEM_DESC;
1298                 return 0;
1299         } else if (unlikely(sg_mapped < 0)) {
1300                 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1301                         scmd_printk(KERN_ERR, scmd, "Failed to map DMA buffer for command\n");
1302                 return sg_mapped;
1303         }
1304
1305         if (scmd->sc_data_direction == DMA_TO_DEVICE) {
1306                 vfc_cmd->flags |= IBMVFC_WRITE;
1307                 vfc_cmd->iu.add_cdb_len |= IBMVFC_WRDATA;
1308         } else {
1309                 vfc_cmd->flags |= IBMVFC_READ;
1310                 vfc_cmd->iu.add_cdb_len |= IBMVFC_RDDATA;
1311         }
1312
1313         if (sg_mapped == 1) {
1314                 ibmvfc_map_sg_list(scmd, sg_mapped, data);
1315                 return 0;
1316         }
1317
1318         vfc_cmd->flags |= IBMVFC_SCATTERLIST;
1319
1320         if (!evt->ext_list) {
1321                 evt->ext_list = dma_pool_alloc(vhost->sg_pool, GFP_ATOMIC,
1322                                                &evt->ext_list_token);
1323
1324                 if (!evt->ext_list) {
1325                         scsi_dma_unmap(scmd);
1326                         if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1327                                 scmd_printk(KERN_ERR, scmd, "Can't allocate memory for scatterlist\n");
1328                         return -ENOMEM;
1329                 }
1330         }
1331
1332         ibmvfc_map_sg_list(scmd, sg_mapped, evt->ext_list);
1333
1334         data->va = evt->ext_list_token;
1335         data->len = sg_mapped * sizeof(struct srp_direct_buf);
1336         data->key = 0;
1337         return 0;
1338 }
1339
1340 /**
1341  * ibmvfc_timeout - Internal command timeout handler
1342  * @evt:        struct ibmvfc_event that timed out
1343  *
1344  * Called when an internally generated command times out
1345  **/
1346 static void ibmvfc_timeout(struct ibmvfc_event *evt)
1347 {
1348         struct ibmvfc_host *vhost = evt->vhost;
1349         dev_err(vhost->dev, "Command timed out (%p). Resetting connection\n", evt);
1350         ibmvfc_reset_host(vhost);
1351 }
1352
1353 /**
1354  * ibmvfc_send_event - Transforms event to u64 array and calls send_crq()
1355  * @evt:                event to be sent
1356  * @vhost:              ibmvfc host struct
1357  * @timeout:    timeout in seconds - 0 means do not time command
1358  *
1359  * Returns the value returned from ibmvfc_send_crq(). (Zero for success)
1360  **/
1361 static int ibmvfc_send_event(struct ibmvfc_event *evt,
1362                              struct ibmvfc_host *vhost, unsigned long timeout)
1363 {
1364         u64 *crq_as_u64 = (u64 *) &evt->crq;
1365         int rc;
1366
1367         /* Copy the IU into the transfer area */
1368         *evt->xfer_iu = evt->iu;
1369         if (evt->crq.format == IBMVFC_CMD_FORMAT)
1370                 evt->xfer_iu->cmd.tag = (u64)evt;
1371         else if (evt->crq.format == IBMVFC_MAD_FORMAT)
1372                 evt->xfer_iu->mad_common.tag = (u64)evt;
1373         else
1374                 BUG();
1375
1376         list_add_tail(&evt->queue, &vhost->sent);
1377         init_timer(&evt->timer);
1378
1379         if (timeout) {
1380                 evt->timer.data = (unsigned long) evt;
1381                 evt->timer.expires = jiffies + (timeout * HZ);
1382                 evt->timer.function = (void (*)(unsigned long))ibmvfc_timeout;
1383                 add_timer(&evt->timer);
1384         }
1385
1386         mb();
1387
1388         if ((rc = ibmvfc_send_crq(vhost, crq_as_u64[0], crq_as_u64[1]))) {
1389                 list_del(&evt->queue);
1390                 del_timer(&evt->timer);
1391
1392                 /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY.
1393                  * Firmware will send a CRQ with a transport event (0xFF) to
1394                  * tell this client what has happened to the transport. This
1395                  * will be handled in ibmvfc_handle_crq()
1396                  */
1397                 if (rc == H_CLOSED) {
1398                         if (printk_ratelimit())
1399                                 dev_warn(vhost->dev, "Send warning. Receive queue closed, will retry.\n");
1400                         if (evt->cmnd)
1401                                 scsi_dma_unmap(evt->cmnd);
1402                         ibmvfc_free_event(evt);
1403                         return SCSI_MLQUEUE_HOST_BUSY;
1404                 }
1405
1406                 dev_err(vhost->dev, "Send error (rc=%d)\n", rc);
1407                 if (evt->cmnd) {
1408                         evt->cmnd->result = DID_ERROR << 16;
1409                         evt->done = ibmvfc_scsi_eh_done;
1410                 } else
1411                         evt->xfer_iu->mad_common.status = IBMVFC_MAD_CRQ_ERROR;
1412
1413                 evt->done(evt);
1414         } else
1415                 ibmvfc_trc_start(evt);
1416
1417         return 0;
1418 }
1419
1420 /**
1421  * ibmvfc_log_error - Log an error for the failed command if appropriate
1422  * @evt:        ibmvfc event to log
1423  *
1424  **/
1425 static void ibmvfc_log_error(struct ibmvfc_event *evt)
1426 {
1427         struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
1428         struct ibmvfc_host *vhost = evt->vhost;
1429         struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
1430         struct scsi_cmnd *cmnd = evt->cmnd;
1431         const char *err = unknown_error;
1432         int index = ibmvfc_get_err_index(vfc_cmd->status, vfc_cmd->error);
1433         int logerr = 0;
1434         int rsp_code = 0;
1435
1436         if (index >= 0) {
1437                 logerr = cmd_status[index].log;
1438                 err = cmd_status[index].name;
1439         }
1440
1441         if (!logerr && (vhost->log_level <= (IBMVFC_DEFAULT_LOG_LEVEL + 1)))
1442                 return;
1443
1444         if (rsp->flags & FCP_RSP_LEN_VALID)
1445                 rsp_code = rsp->data.info.rsp_code;
1446
1447         scmd_printk(KERN_ERR, cmnd, "Command (%02X) failed: %s (%x:%x) "
1448                     "flags: %x fcp_rsp: %x, resid=%d, scsi_status: %x\n",
1449                     cmnd->cmnd[0], err, vfc_cmd->status, vfc_cmd->error,
1450                     rsp->flags, rsp_code, scsi_get_resid(cmnd), rsp->scsi_status);
1451 }
1452
1453 /**
1454  * ibmvfc_scsi_done - Handle responses from commands
1455  * @evt:        ibmvfc event to be handled
1456  *
1457  * Used as a callback when sending scsi cmds.
1458  **/
1459 static void ibmvfc_scsi_done(struct ibmvfc_event *evt)
1460 {
1461         struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
1462         struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
1463         struct scsi_cmnd *cmnd = evt->cmnd;
1464         u32 rsp_len = 0;
1465         u32 sense_len = rsp->fcp_sense_len;
1466
1467         if (cmnd) {
1468                 if (vfc_cmd->response_flags & IBMVFC_ADAPTER_RESID_VALID)
1469                         scsi_set_resid(cmnd, vfc_cmd->adapter_resid);
1470                 else if (rsp->flags & FCP_RESID_UNDER)
1471                         scsi_set_resid(cmnd, rsp->fcp_resid);
1472                 else
1473                         scsi_set_resid(cmnd, 0);
1474
1475                 if (vfc_cmd->status) {
1476                         cmnd->result = ibmvfc_get_err_result(vfc_cmd);
1477
1478                         if (rsp->flags & FCP_RSP_LEN_VALID)
1479                                 rsp_len = rsp->fcp_rsp_len;
1480                         if ((sense_len + rsp_len) > SCSI_SENSE_BUFFERSIZE)
1481                                 sense_len = SCSI_SENSE_BUFFERSIZE - rsp_len;
1482                         if ((rsp->flags & FCP_SNS_LEN_VALID) && rsp->fcp_sense_len && rsp_len <= 8)
1483                                 memcpy(cmnd->sense_buffer, rsp->data.sense + rsp_len, sense_len);
1484                         if ((vfc_cmd->status & IBMVFC_VIOS_FAILURE) && (vfc_cmd->error == IBMVFC_PLOGI_REQUIRED))
1485                                 ibmvfc_reinit_host(evt->vhost);
1486
1487                         if (!cmnd->result && (!scsi_get_resid(cmnd) || (rsp->flags & FCP_RESID_OVER)))
1488                                 cmnd->result = (DID_ERROR << 16);
1489
1490                         ibmvfc_log_error(evt);
1491                 }
1492
1493                 if (!cmnd->result &&
1494                     (scsi_bufflen(cmnd) - scsi_get_resid(cmnd) < cmnd->underflow))
1495                         cmnd->result = (DID_ERROR << 16);
1496
1497                 scsi_dma_unmap(cmnd);
1498                 cmnd->scsi_done(cmnd);
1499         }
1500
1501         if (evt->eh_comp)
1502                 complete(evt->eh_comp);
1503
1504         ibmvfc_free_event(evt);
1505 }
1506
1507 /**
1508  * ibmvfc_host_chkready - Check if the host can accept commands
1509  * @vhost:       struct ibmvfc host
1510  *
1511  * Returns:
1512  *      1 if host can accept command / 0 if not
1513  **/
1514 static inline int ibmvfc_host_chkready(struct ibmvfc_host *vhost)
1515 {
1516         int result = 0;
1517
1518         switch (vhost->state) {
1519         case IBMVFC_LINK_DEAD:
1520         case IBMVFC_HOST_OFFLINE:
1521                 result = DID_NO_CONNECT << 16;
1522                 break;
1523         case IBMVFC_NO_CRQ:
1524         case IBMVFC_INITIALIZING:
1525         case IBMVFC_HALTED:
1526         case IBMVFC_LINK_DOWN:
1527                 result = DID_REQUEUE << 16;
1528                 break;
1529         case IBMVFC_ACTIVE:
1530                 result = 0;
1531                 break;
1532         };
1533
1534         return result;
1535 }
1536
1537 /**
1538  * ibmvfc_queuecommand - The queuecommand function of the scsi template
1539  * @cmnd:       struct scsi_cmnd to be executed
1540  * @done:       Callback function to be called when cmnd is completed
1541  *
1542  * Returns:
1543  *      0 on success / other on failure
1544  **/
1545 static int ibmvfc_queuecommand(struct scsi_cmnd *cmnd,
1546                                void (*done) (struct scsi_cmnd *))
1547 {
1548         struct ibmvfc_host *vhost = shost_priv(cmnd->device->host);
1549         struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
1550         struct ibmvfc_cmd *vfc_cmd;
1551         struct ibmvfc_event *evt;
1552         u8 tag[2];
1553         int rc;
1554
1555         if (unlikely((rc = fc_remote_port_chkready(rport))) ||
1556             unlikely((rc = ibmvfc_host_chkready(vhost)))) {
1557                 cmnd->result = rc;
1558                 done(cmnd);
1559                 return 0;
1560         }
1561
1562         cmnd->result = (DID_OK << 16);
1563         evt = ibmvfc_get_event(vhost);
1564         ibmvfc_init_event(evt, ibmvfc_scsi_done, IBMVFC_CMD_FORMAT);
1565         evt->cmnd = cmnd;
1566         cmnd->scsi_done = done;
1567         vfc_cmd = &evt->iu.cmd;
1568         memset(vfc_cmd, 0, sizeof(*vfc_cmd));
1569         vfc_cmd->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
1570         vfc_cmd->resp.len = sizeof(vfc_cmd->rsp);
1571         vfc_cmd->frame_type = IBMVFC_SCSI_FCP_TYPE;
1572         vfc_cmd->payload_len = sizeof(vfc_cmd->iu);
1573         vfc_cmd->resp_len = sizeof(vfc_cmd->rsp);
1574         vfc_cmd->cancel_key = (unsigned long)cmnd->device->hostdata;
1575         vfc_cmd->tgt_scsi_id = rport->port_id;
1576         if ((rport->supported_classes & FC_COS_CLASS3) &&
1577             (fc_host_supported_classes(vhost->host) & FC_COS_CLASS3))
1578                 vfc_cmd->flags = IBMVFC_CLASS_3_ERR;
1579         vfc_cmd->iu.xfer_len = scsi_bufflen(cmnd);
1580         int_to_scsilun(cmnd->device->lun, &vfc_cmd->iu.lun);
1581         memcpy(vfc_cmd->iu.cdb, cmnd->cmnd, cmnd->cmd_len);
1582
1583         if (scsi_populate_tag_msg(cmnd, tag)) {
1584                 vfc_cmd->task_tag = tag[1];
1585                 switch (tag[0]) {
1586                 case MSG_SIMPLE_TAG:
1587                         vfc_cmd->iu.pri_task_attr = IBMVFC_SIMPLE_TASK;
1588                         break;
1589                 case MSG_HEAD_TAG:
1590                         vfc_cmd->iu.pri_task_attr = IBMVFC_HEAD_OF_QUEUE;
1591                         break;
1592                 case MSG_ORDERED_TAG:
1593                         vfc_cmd->iu.pri_task_attr = IBMVFC_ORDERED_TASK;
1594                         break;
1595                 };
1596         }
1597
1598         if (likely(!(rc = ibmvfc_map_sg_data(cmnd, evt, vfc_cmd, vhost->dev))))
1599                 return ibmvfc_send_event(evt, vhost, 0);
1600
1601         ibmvfc_free_event(evt);
1602         if (rc == -ENOMEM)
1603                 return SCSI_MLQUEUE_HOST_BUSY;
1604
1605         if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1606                 scmd_printk(KERN_ERR, cmnd,
1607                             "Failed to map DMA buffer for command. rc=%d\n", rc);
1608
1609         cmnd->result = DID_ERROR << 16;
1610         done(cmnd);
1611         return 0;
1612 }
1613
1614 /**
1615  * ibmvfc_sync_completion - Signal that a synchronous command has completed
1616  * @evt:        ibmvfc event struct
1617  *
1618  **/
1619 static void ibmvfc_sync_completion(struct ibmvfc_event *evt)
1620 {
1621         /* copy the response back */
1622         if (evt->sync_iu)
1623                 *evt->sync_iu = *evt->xfer_iu;
1624
1625         complete(&evt->comp);
1626 }
1627
1628 /**
1629  * ibmvfc_reset_device - Reset the device with the specified reset type
1630  * @sdev:       scsi device to reset
1631  * @type:       reset type
1632  * @desc:       reset type description for log messages
1633  *
1634  * Returns:
1635  *      0 on success / other on failure
1636  **/
1637 static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
1638 {
1639         struct ibmvfc_host *vhost = shost_priv(sdev->host);
1640         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
1641         struct ibmvfc_cmd *tmf;
1642         struct ibmvfc_event *evt = NULL;
1643         union ibmvfc_iu rsp_iu;
1644         struct ibmvfc_fcp_rsp *fc_rsp = &rsp_iu.cmd.rsp;
1645         int rsp_rc = -EBUSY;
1646         unsigned long flags;
1647         int rsp_code = 0;
1648
1649         spin_lock_irqsave(vhost->host->host_lock, flags);
1650         if (vhost->state == IBMVFC_ACTIVE) {
1651                 evt = ibmvfc_get_event(vhost);
1652                 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
1653
1654                 tmf = &evt->iu.cmd;
1655                 memset(tmf, 0, sizeof(*tmf));
1656                 tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
1657                 tmf->resp.len = sizeof(tmf->rsp);
1658                 tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
1659                 tmf->payload_len = sizeof(tmf->iu);
1660                 tmf->resp_len = sizeof(tmf->rsp);
1661                 tmf->cancel_key = (unsigned long)sdev->hostdata;
1662                 tmf->tgt_scsi_id = rport->port_id;
1663                 int_to_scsilun(sdev->lun, &tmf->iu.lun);
1664                 tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
1665                 tmf->iu.tmf_flags = type;
1666                 evt->sync_iu = &rsp_iu;
1667
1668                 init_completion(&evt->comp);
1669                 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
1670         }
1671         spin_unlock_irqrestore(vhost->host->host_lock, flags);
1672
1673         if (rsp_rc != 0) {
1674                 sdev_printk(KERN_ERR, sdev, "Failed to send %s reset event. rc=%d\n",
1675                             desc, rsp_rc);
1676                 return -EIO;
1677         }
1678
1679         sdev_printk(KERN_INFO, sdev, "Resetting %s\n", desc);
1680         wait_for_completion(&evt->comp);
1681
1682         if (rsp_iu.cmd.status) {
1683                 if (fc_rsp->flags & FCP_RSP_LEN_VALID)
1684                         rsp_code = fc_rsp->data.info.rsp_code;
1685
1686                 sdev_printk(KERN_ERR, sdev, "%s reset failed: %s (%x:%x) "
1687                             "flags: %x fcp_rsp: %x, scsi_status: %x\n",
1688                             desc, ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
1689                             rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
1690                             fc_rsp->scsi_status);
1691                 rsp_rc = -EIO;
1692         } else
1693                 sdev_printk(KERN_INFO, sdev, "%s reset successful\n", desc);
1694
1695         spin_lock_irqsave(vhost->host->host_lock, flags);
1696         ibmvfc_free_event(evt);
1697         spin_unlock_irqrestore(vhost->host->host_lock, flags);
1698         return rsp_rc;
1699 }
1700
1701 /**
1702  * ibmvfc_abort_task_set - Abort outstanding commands to the device
1703  * @sdev:       scsi device to abort commands
1704  *
1705  * This sends an Abort Task Set to the VIOS for the specified device. This does
1706  * NOT send any cancel to the VIOS. That must be done separately.
1707  *
1708  * Returns:
1709  *      0 on success / other on failure
1710  **/
1711 static int ibmvfc_abort_task_set(struct scsi_device *sdev)
1712 {
1713         struct ibmvfc_host *vhost = shost_priv(sdev->host);
1714         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
1715         struct ibmvfc_cmd *tmf;
1716         struct ibmvfc_event *evt, *found_evt;
1717         union ibmvfc_iu rsp_iu;
1718         struct ibmvfc_fcp_rsp *fc_rsp = &rsp_iu.cmd.rsp;
1719         int rsp_rc = -EBUSY;
1720         unsigned long flags;
1721         int rsp_code = 0;
1722
1723         spin_lock_irqsave(vhost->host->host_lock, flags);
1724         found_evt = NULL;
1725         list_for_each_entry(evt, &vhost->sent, queue) {
1726                 if (evt->cmnd && evt->cmnd->device == sdev) {
1727                         found_evt = evt;
1728                         break;
1729                 }
1730         }
1731
1732         if (!found_evt) {
1733                 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1734                         sdev_printk(KERN_INFO, sdev, "No events found to abort\n");
1735                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1736                 return 0;
1737         }
1738
1739         if (vhost->state == IBMVFC_ACTIVE) {
1740                 evt = ibmvfc_get_event(vhost);
1741                 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
1742
1743                 tmf = &evt->iu.cmd;
1744                 memset(tmf, 0, sizeof(*tmf));
1745                 tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
1746                 tmf->resp.len = sizeof(tmf->rsp);
1747                 tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
1748                 tmf->payload_len = sizeof(tmf->iu);
1749                 tmf->resp_len = sizeof(tmf->rsp);
1750                 tmf->cancel_key = (unsigned long)sdev->hostdata;
1751                 tmf->tgt_scsi_id = rport->port_id;
1752                 int_to_scsilun(sdev->lun, &tmf->iu.lun);
1753                 tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
1754                 tmf->iu.tmf_flags = IBMVFC_ABORT_TASK_SET;
1755                 evt->sync_iu = &rsp_iu;
1756
1757                 init_completion(&evt->comp);
1758                 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
1759         }
1760
1761         spin_unlock_irqrestore(vhost->host->host_lock, flags);
1762
1763         if (rsp_rc != 0) {
1764                 sdev_printk(KERN_ERR, sdev, "Failed to send abort. rc=%d\n", rsp_rc);
1765                 return -EIO;
1766         }
1767
1768         sdev_printk(KERN_INFO, sdev, "Aborting outstanding commands\n");
1769         wait_for_completion(&evt->comp);
1770
1771         if (rsp_iu.cmd.status) {
1772                 if (fc_rsp->flags & FCP_RSP_LEN_VALID)
1773                         rsp_code = fc_rsp->data.info.rsp_code;
1774
1775                 sdev_printk(KERN_ERR, sdev, "Abort failed: %s (%x:%x) "
1776                             "flags: %x fcp_rsp: %x, scsi_status: %x\n",
1777                             ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
1778                             rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
1779                             fc_rsp->scsi_status);
1780                 rsp_rc = -EIO;
1781         } else
1782                 sdev_printk(KERN_INFO, sdev, "Abort successful\n");
1783
1784         spin_lock_irqsave(vhost->host->host_lock, flags);
1785         ibmvfc_free_event(evt);
1786         spin_unlock_irqrestore(vhost->host->host_lock, flags);
1787         return rsp_rc;
1788 }
1789
1790 /**
1791  * ibmvfc_cancel_all - Cancel all outstanding commands to the device
1792  * @sdev:       scsi device to cancel commands
1793  * @type:       type of error recovery being performed
1794  *
1795  * This sends a cancel to the VIOS for the specified device. This does
1796  * NOT send any abort to the actual device. That must be done separately.
1797  *
1798  * Returns:
1799  *      0 on success / other on failure
1800  **/
1801 static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
1802 {
1803         struct ibmvfc_host *vhost = shost_priv(sdev->host);
1804         struct scsi_target *starget = scsi_target(sdev);
1805         struct fc_rport *rport = starget_to_rport(starget);
1806         struct ibmvfc_tmf *tmf;
1807         struct ibmvfc_event *evt, *found_evt;
1808         union ibmvfc_iu rsp;
1809         int rsp_rc = -EBUSY;
1810         unsigned long flags;
1811         u16 status;
1812
1813         ENTER;
1814         spin_lock_irqsave(vhost->host->host_lock, flags);
1815         found_evt = NULL;
1816         list_for_each_entry(evt, &vhost->sent, queue) {
1817                 if (evt->cmnd && evt->cmnd->device == sdev) {
1818                         found_evt = evt;
1819                         break;
1820                 }
1821         }
1822
1823         if (!found_evt) {
1824                 if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
1825                         sdev_printk(KERN_INFO, sdev, "No events found to cancel\n");
1826                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1827                 return 0;
1828         }
1829
1830         if (vhost->state == IBMVFC_ACTIVE) {
1831                 evt = ibmvfc_get_event(vhost);
1832                 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
1833
1834                 tmf = &evt->iu.tmf;
1835                 memset(tmf, 0, sizeof(*tmf));
1836                 tmf->common.version = 1;
1837                 tmf->common.opcode = IBMVFC_TMF_MAD;
1838                 tmf->common.length = sizeof(*tmf);
1839                 tmf->scsi_id = rport->port_id;
1840                 int_to_scsilun(sdev->lun, &tmf->lun);
1841                 tmf->flags = (type | IBMVFC_TMF_LUA_VALID);
1842                 tmf->cancel_key = (unsigned long)sdev->hostdata;
1843                 tmf->my_cancel_key = (unsigned long)starget->hostdata;
1844
1845                 evt->sync_iu = &rsp;
1846                 init_completion(&evt->comp);
1847                 rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
1848         }
1849
1850         spin_unlock_irqrestore(vhost->host->host_lock, flags);
1851
1852         if (rsp_rc != 0) {
1853                 sdev_printk(KERN_ERR, sdev, "Failed to send cancel event. rc=%d\n", rsp_rc);
1854                 return -EIO;
1855         }
1856
1857         sdev_printk(KERN_INFO, sdev, "Cancelling outstanding commands.\n");
1858
1859         wait_for_completion(&evt->comp);
1860         status = rsp.mad_common.status;
1861         spin_lock_irqsave(vhost->host->host_lock, flags);
1862         ibmvfc_free_event(evt);
1863         spin_unlock_irqrestore(vhost->host->host_lock, flags);
1864
1865         if (status != IBMVFC_MAD_SUCCESS) {
1866                 sdev_printk(KERN_WARNING, sdev, "Cancel failed with rc=%x\n", status);
1867                 return -EIO;
1868         }
1869
1870         sdev_printk(KERN_INFO, sdev, "Successfully cancelled outstanding commands\n");
1871         return 0;
1872 }
1873
1874 /**
1875  * ibmvfc_match_target - Match function for specified target
1876  * @evt:        ibmvfc event struct
1877  * @device:     device to match (starget)
1878  *
1879  * Returns:
1880  *      1 if event matches starget / 0 if event does not match starget
1881  **/
1882 static int ibmvfc_match_target(struct ibmvfc_event *evt, void *device)
1883 {
1884         if (evt->cmnd && scsi_target(evt->cmnd->device) == device)
1885                 return 1;
1886         return 0;
1887 }
1888
1889 /**
1890  * ibmvfc_match_lun - Match function for specified LUN
1891  * @evt:        ibmvfc event struct
1892  * @device:     device to match (sdev)
1893  *
1894  * Returns:
1895  *      1 if event matches sdev / 0 if event does not match sdev
1896  **/
1897 static int ibmvfc_match_lun(struct ibmvfc_event *evt, void *device)
1898 {
1899         if (evt->cmnd && evt->cmnd->device == device)
1900                 return 1;
1901         return 0;
1902 }
1903
1904 /**
1905  * ibmvfc_wait_for_ops - Wait for ops to complete
1906  * @vhost:      ibmvfc host struct
1907  * @device:     device to match (starget or sdev)
1908  * @match:      match function
1909  *
1910  * Returns:
1911  *      SUCCESS / FAILED
1912  **/
1913 static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
1914                                int (*match) (struct ibmvfc_event *, void *))
1915 {
1916         struct ibmvfc_event *evt;
1917         DECLARE_COMPLETION_ONSTACK(comp);
1918         int wait;
1919         unsigned long flags;
1920         signed long timeout = init_timeout * HZ;
1921
1922         ENTER;
1923         do {
1924                 wait = 0;
1925                 spin_lock_irqsave(vhost->host->host_lock, flags);
1926                 list_for_each_entry(evt, &vhost->sent, queue) {
1927                         if (match(evt, device)) {
1928                                 evt->eh_comp = &comp;
1929                                 wait++;
1930                         }
1931                 }
1932                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1933
1934                 if (wait) {
1935                         timeout = wait_for_completion_timeout(&comp, timeout);
1936
1937                         if (!timeout) {
1938                                 wait = 0;
1939                                 spin_lock_irqsave(vhost->host->host_lock, flags);
1940                                 list_for_each_entry(evt, &vhost->sent, queue) {
1941                                         if (match(evt, device)) {
1942                                                 evt->eh_comp = NULL;
1943                                                 wait++;
1944                                         }
1945                                 }
1946                                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
1947                                 if (wait)
1948                                         dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
1949                                 LEAVE;
1950                                 return wait ? FAILED : SUCCESS;
1951                         }
1952                 }
1953         } while (wait);
1954
1955         LEAVE;
1956         return SUCCESS;
1957 }
1958
1959 /**
1960  * ibmvfc_eh_abort_handler - Abort a command
1961  * @cmd:        scsi command to abort
1962  *
1963  * Returns:
1964  *      SUCCESS / FAILED
1965  **/
1966 static int ibmvfc_eh_abort_handler(struct scsi_cmnd *cmd)
1967 {
1968         struct scsi_device *sdev = cmd->device;
1969         struct ibmvfc_host *vhost = shost_priv(sdev->host);
1970         int cancel_rc, abort_rc;
1971         int rc = FAILED;
1972
1973         ENTER;
1974         ibmvfc_wait_while_resetting(vhost);
1975         cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
1976         abort_rc = ibmvfc_abort_task_set(sdev);
1977
1978         if (!cancel_rc && !abort_rc)
1979                 rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
1980
1981         LEAVE;
1982         return rc;
1983 }
1984
1985 /**
1986  * ibmvfc_eh_device_reset_handler - Reset a single LUN
1987  * @cmd:        scsi command struct
1988  *
1989  * Returns:
1990  *      SUCCESS / FAILED
1991  **/
1992 static int ibmvfc_eh_device_reset_handler(struct scsi_cmnd *cmd)
1993 {
1994         struct scsi_device *sdev = cmd->device;
1995         struct ibmvfc_host *vhost = shost_priv(sdev->host);
1996         int cancel_rc, reset_rc;
1997         int rc = FAILED;
1998
1999         ENTER;
2000         ibmvfc_wait_while_resetting(vhost);
2001         cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_LUN_RESET);
2002         reset_rc = ibmvfc_reset_device(sdev, IBMVFC_LUN_RESET, "LUN");
2003
2004         if (!cancel_rc && !reset_rc)
2005                 rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
2006
2007         LEAVE;
2008         return rc;
2009 }
2010
2011 /**
2012  * ibmvfc_dev_cancel_all - Device iterated cancel all function
2013  * @sdev:       scsi device struct
2014  * @data:       return code
2015  *
2016  **/
2017 static void ibmvfc_dev_cancel_all(struct scsi_device *sdev, void *data)
2018 {
2019         unsigned long *rc = data;
2020         *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_TGT_RESET);
2021 }
2022
2023 /**
2024  * ibmvfc_dev_abort_all - Device iterated abort task set function
2025  * @sdev:       scsi device struct
2026  * @data:       return code
2027  *
2028  **/
2029 static void ibmvfc_dev_abort_all(struct scsi_device *sdev, void *data)
2030 {
2031         unsigned long *rc = data;
2032         *rc |= ibmvfc_abort_task_set(sdev);
2033 }
2034
2035 /**
2036  * ibmvfc_eh_target_reset_handler - Reset the target
2037  * @cmd:        scsi command struct
2038  *
2039  * Returns:
2040  *      SUCCESS / FAILED
2041  **/
2042 static int ibmvfc_eh_target_reset_handler(struct scsi_cmnd *cmd)
2043 {
2044         struct scsi_device *sdev = cmd->device;
2045         struct ibmvfc_host *vhost = shost_priv(sdev->host);
2046         struct scsi_target *starget = scsi_target(sdev);
2047         int reset_rc;
2048         int rc = FAILED;
2049         unsigned long cancel_rc = 0;
2050
2051         ENTER;
2052         ibmvfc_wait_while_resetting(vhost);
2053         starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all);
2054         reset_rc = ibmvfc_reset_device(sdev, IBMVFC_TARGET_RESET, "target");
2055
2056         if (!cancel_rc && !reset_rc)
2057                 rc = ibmvfc_wait_for_ops(vhost, starget, ibmvfc_match_target);
2058
2059         LEAVE;
2060         return rc;
2061 }
2062
2063 /**
2064  * ibmvfc_eh_host_reset_handler - Reset the connection to the server
2065  * @cmd:        struct scsi_cmnd having problems
2066  *
2067  **/
2068 static int ibmvfc_eh_host_reset_handler(struct scsi_cmnd *cmd)
2069 {
2070         int rc;
2071         struct ibmvfc_host *vhost = shost_priv(cmd->device->host);
2072
2073         dev_err(vhost->dev, "Resetting connection due to error recovery\n");
2074         rc = ibmvfc_issue_fc_host_lip(vhost->host);
2075         return rc ? FAILED : SUCCESS;
2076 }
2077
2078 /**
2079  * ibmvfc_terminate_rport_io - Terminate all pending I/O to the rport.
2080  * @rport:              rport struct
2081  *
2082  * Return value:
2083  *      none
2084  **/
2085 static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
2086 {
2087         struct scsi_target *starget = to_scsi_target(&rport->dev);
2088         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2089         struct ibmvfc_host *vhost = shost_priv(shost);
2090         unsigned long cancel_rc = 0;
2091         unsigned long abort_rc = 0;
2092         int rc = FAILED;
2093
2094         ENTER;
2095         starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all);
2096         starget_for_each_device(starget, &abort_rc, ibmvfc_dev_abort_all);
2097
2098         if (!cancel_rc && !abort_rc)
2099                 rc = ibmvfc_wait_for_ops(vhost, starget, ibmvfc_match_target);
2100
2101         if (rc == FAILED)
2102                 ibmvfc_issue_fc_host_lip(shost);
2103         LEAVE;
2104 }
2105
2106 static const struct {
2107         enum ibmvfc_async_event ae;
2108         const char *desc;
2109 } ae_desc [] = {
2110         { IBMVFC_AE_ELS_PLOGI,          "PLOGI" },
2111         { IBMVFC_AE_ELS_LOGO,           "LOGO" },
2112         { IBMVFC_AE_ELS_PRLO,           "PRLO" },
2113         { IBMVFC_AE_SCN_NPORT,          "N-Port SCN" },
2114         { IBMVFC_AE_SCN_GROUP,          "Group SCN" },
2115         { IBMVFC_AE_SCN_DOMAIN,         "Domain SCN" },
2116         { IBMVFC_AE_SCN_FABRIC,         "Fabric SCN" },
2117         { IBMVFC_AE_LINK_UP,            "Link Up" },
2118         { IBMVFC_AE_LINK_DOWN,          "Link Down" },
2119         { IBMVFC_AE_LINK_DEAD,          "Link Dead" },
2120         { IBMVFC_AE_HALT,                       "Halt" },
2121         { IBMVFC_AE_RESUME,             "Resume" },
2122         { IBMVFC_AE_ADAPTER_FAILED,     "Adapter Failed" },
2123 };
2124
2125 static const char *unknown_ae = "Unknown async";
2126
2127 /**
2128  * ibmvfc_get_ae_desc - Get text description for async event
2129  * @ae: async event
2130  *
2131  **/
2132 static const char *ibmvfc_get_ae_desc(u64 ae)
2133 {
2134         int i;
2135
2136         for (i = 0; i < ARRAY_SIZE(ae_desc); i++)
2137                 if (ae_desc[i].ae == ae)
2138                         return ae_desc[i].desc;
2139
2140         return unknown_ae;
2141 }
2142
2143 /**
2144  * ibmvfc_handle_async - Handle an async event from the adapter
2145  * @crq:        crq to process
2146  * @vhost:      ibmvfc host struct
2147  *
2148  **/
2149 static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
2150                                 struct ibmvfc_host *vhost)
2151 {
2152         const char *desc = ibmvfc_get_ae_desc(crq->event);
2153
2154         ibmvfc_log(vhost, 3, "%s event received. scsi_id: %llx, wwpn: %llx,"
2155                    " node_name: %llx\n", desc, crq->scsi_id, crq->wwpn, crq->node_name);
2156
2157         switch (crq->event) {
2158         case IBMVFC_AE_LINK_UP:
2159         case IBMVFC_AE_RESUME:
2160                 vhost->events_to_log |= IBMVFC_AE_LINKUP;
2161                 vhost->delay_init = 1;
2162                 __ibmvfc_reset_host(vhost);
2163                 break;
2164         case IBMVFC_AE_SCN_FABRIC:
2165         case IBMVFC_AE_SCN_DOMAIN:
2166                 vhost->events_to_log |= IBMVFC_AE_RSCN;
2167                 vhost->delay_init = 1;
2168                 __ibmvfc_reset_host(vhost);
2169                 break;
2170         case IBMVFC_AE_SCN_NPORT:
2171         case IBMVFC_AE_SCN_GROUP:
2172                 vhost->events_to_log |= IBMVFC_AE_RSCN;
2173         case IBMVFC_AE_ELS_LOGO:
2174         case IBMVFC_AE_ELS_PRLO:
2175         case IBMVFC_AE_ELS_PLOGI:
2176                 ibmvfc_reinit_host(vhost);
2177                 break;
2178         case IBMVFC_AE_LINK_DOWN:
2179         case IBMVFC_AE_ADAPTER_FAILED:
2180                 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2181                 break;
2182         case IBMVFC_AE_LINK_DEAD:
2183                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
2184                 break;
2185         case IBMVFC_AE_HALT:
2186                 ibmvfc_link_down(vhost, IBMVFC_HALTED);
2187                 break;
2188         default:
2189                 dev_err(vhost->dev, "Unknown async event received: %lld\n", crq->event);
2190                 break;
2191         };
2192 }
2193
2194 /**
2195  * ibmvfc_handle_crq - Handles and frees received events in the CRQ
2196  * @crq:        Command/Response queue
2197  * @vhost:      ibmvfc host struct
2198  *
2199  **/
2200 static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
2201 {
2202         long rc;
2203         struct ibmvfc_event *evt = (struct ibmvfc_event *)crq->ioba;
2204
2205         switch (crq->valid) {
2206         case IBMVFC_CRQ_INIT_RSP:
2207                 switch (crq->format) {
2208                 case IBMVFC_CRQ_INIT:
2209                         dev_info(vhost->dev, "Partner initialized\n");
2210                         /* Send back a response */
2211                         rc = ibmvfc_send_crq_init_complete(vhost);
2212                         if (rc == 0)
2213                                 ibmvfc_init_host(vhost, 0);
2214                         else
2215                                 dev_err(vhost->dev, "Unable to send init rsp. rc=%ld\n", rc);
2216                         break;
2217                 case IBMVFC_CRQ_INIT_COMPLETE:
2218                         dev_info(vhost->dev, "Partner initialization complete\n");
2219                         ibmvfc_init_host(vhost, 0);
2220                         break;
2221                 default:
2222                         dev_err(vhost->dev, "Unknown crq message type: %d\n", crq->format);
2223                 }
2224                 return;
2225         case IBMVFC_CRQ_XPORT_EVENT:
2226                 vhost->state = IBMVFC_NO_CRQ;
2227                 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
2228                 if (crq->format == IBMVFC_PARTITION_MIGRATED) {
2229                         /* We need to re-setup the interpartition connection */
2230                         dev_info(vhost->dev, "Re-enabling adapter\n");
2231                         vhost->client_migrated = 1;
2232                         ibmvfc_purge_requests(vhost, DID_REQUEUE);
2233                         if ((rc = ibmvfc_reenable_crq_queue(vhost)) ||
2234                             (rc = ibmvfc_send_crq_init(vhost))) {
2235                                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
2236                                 dev_err(vhost->dev, "Error after enable (rc=%ld)\n", rc);
2237                         } else
2238                                 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2239                 } else {
2240                         dev_err(vhost->dev, "Virtual adapter failed (rc=%d)\n", crq->format);
2241
2242                         ibmvfc_purge_requests(vhost, DID_ERROR);
2243                         if ((rc = ibmvfc_reset_crq(vhost)) ||
2244                             (rc = ibmvfc_send_crq_init(vhost))) {
2245                                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
2246                                 dev_err(vhost->dev, "Error after reset (rc=%ld)\n", rc);
2247                         } else
2248                                 ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
2249                 }
2250                 return;
2251         case IBMVFC_CRQ_CMD_RSP:
2252                 break;
2253         default:
2254                 dev_err(vhost->dev, "Got an invalid message type 0x%02x\n", crq->valid);
2255                 return;
2256         }
2257
2258         if (crq->format == IBMVFC_ASYNC_EVENT)
2259                 return;
2260
2261         /* The only kind of payload CRQs we should get are responses to
2262          * things we send. Make sure this response is to something we
2263          * actually sent
2264          */
2265         if (unlikely(!ibmvfc_valid_event(&vhost->pool, evt))) {
2266                 dev_err(vhost->dev, "Returned correlation_token 0x%08llx is invalid!\n",
2267                         crq->ioba);
2268                 return;
2269         }
2270
2271         if (unlikely(atomic_read(&evt->free))) {
2272                 dev_err(vhost->dev, "Received duplicate correlation_token 0x%08llx!\n",
2273                         crq->ioba);
2274                 return;
2275         }
2276
2277         del_timer(&evt->timer);
2278         list_del(&evt->queue);
2279         ibmvfc_trc_end(evt);
2280         evt->done(evt);
2281 }
2282
2283 /**
2284  * ibmvfc_scan_finished - Check if the device scan is done.
2285  * @shost:      scsi host struct
2286  * @time:       current elapsed time
2287  *
2288  * Returns:
2289  *      0 if scan is not done / 1 if scan is done
2290  **/
2291 static int ibmvfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
2292 {
2293         unsigned long flags;
2294         struct ibmvfc_host *vhost = shost_priv(shost);
2295         int done = 0;
2296
2297         spin_lock_irqsave(shost->host_lock, flags);
2298         if (time >= (init_timeout * HZ)) {
2299                 dev_info(vhost->dev, "Scan taking longer than %d seconds, "
2300                          "continuing initialization\n", init_timeout);
2301                 done = 1;
2302         }
2303
2304         if (vhost->state != IBMVFC_NO_CRQ && vhost->action == IBMVFC_HOST_ACTION_NONE)
2305                 done = 1;
2306         spin_unlock_irqrestore(shost->host_lock, flags);
2307         return done;
2308 }
2309
2310 /**
2311  * ibmvfc_slave_alloc - Setup the device's task set value
2312  * @sdev:       struct scsi_device device to configure
2313  *
2314  * Set the device's task set value so that error handling works as
2315  * expected.
2316  *
2317  * Returns:
2318  *      0 on success / -ENXIO if device does not exist
2319  **/
2320 static int ibmvfc_slave_alloc(struct scsi_device *sdev)
2321 {
2322         struct Scsi_Host *shost = sdev->host;
2323         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2324         struct ibmvfc_host *vhost = shost_priv(shost);
2325         unsigned long flags = 0;
2326
2327         if (!rport || fc_remote_port_chkready(rport))
2328                 return -ENXIO;
2329
2330         spin_lock_irqsave(shost->host_lock, flags);
2331         sdev->hostdata = (void *)(unsigned long)vhost->task_set++;
2332         spin_unlock_irqrestore(shost->host_lock, flags);
2333         return 0;
2334 }
2335
2336 /**
2337  * ibmvfc_target_alloc - Setup the target's task set value
2338  * @starget:    struct scsi_target
2339  *
2340  * Set the target's task set value so that error handling works as
2341  * expected.
2342  *
2343  * Returns:
2344  *      0 on success / -ENXIO if device does not exist
2345  **/
2346 static int ibmvfc_target_alloc(struct scsi_target *starget)
2347 {
2348         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2349         struct ibmvfc_host *vhost = shost_priv(shost);
2350         unsigned long flags = 0;
2351
2352         spin_lock_irqsave(shost->host_lock, flags);
2353         starget->hostdata = (void *)(unsigned long)vhost->task_set++;
2354         spin_unlock_irqrestore(shost->host_lock, flags);
2355         return 0;
2356 }
2357
2358 /**
2359  * ibmvfc_slave_configure - Configure the device
2360  * @sdev:       struct scsi_device device to configure
2361  *
2362  * Enable allow_restart for a device if it is a disk. Adjust the
2363  * queue_depth here also.
2364  *
2365  * Returns:
2366  *      0
2367  **/
2368 static int ibmvfc_slave_configure(struct scsi_device *sdev)
2369 {
2370         struct Scsi_Host *shost = sdev->host;
2371         struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
2372         unsigned long flags = 0;
2373
2374         spin_lock_irqsave(shost->host_lock, flags);
2375         if (sdev->type == TYPE_DISK)
2376                 sdev->allow_restart = 1;
2377
2378         if (sdev->tagged_supported) {
2379                 scsi_set_tag_type(sdev, MSG_SIMPLE_TAG);
2380                 scsi_activate_tcq(sdev, sdev->queue_depth);
2381         } else
2382                 scsi_deactivate_tcq(sdev, sdev->queue_depth);
2383
2384         rport->dev_loss_tmo = dev_loss_tmo;
2385         spin_unlock_irqrestore(shost->host_lock, flags);
2386         return 0;
2387 }
2388
2389 /**
2390  * ibmvfc_change_queue_depth - Change the device's queue depth
2391  * @sdev:       scsi device struct
2392  * @qdepth:     depth to set
2393  *
2394  * Return value:
2395  *      actual depth set
2396  **/
2397 static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth)
2398 {
2399         if (qdepth > IBMVFC_MAX_CMDS_PER_LUN)
2400                 qdepth = IBMVFC_MAX_CMDS_PER_LUN;
2401
2402         scsi_adjust_queue_depth(sdev, 0, qdepth);
2403         return sdev->queue_depth;
2404 }
2405
2406 /**
2407  * ibmvfc_change_queue_type - Change the device's queue type
2408  * @sdev:               scsi device struct
2409  * @tag_type:   type of tags to use
2410  *
2411  * Return value:
2412  *      actual queue type set
2413  **/
2414 static int ibmvfc_change_queue_type(struct scsi_device *sdev, int tag_type)
2415 {
2416         if (sdev->tagged_supported) {
2417                 scsi_set_tag_type(sdev, tag_type);
2418
2419                 if (tag_type)
2420                         scsi_activate_tcq(sdev, sdev->queue_depth);
2421                 else
2422                         scsi_deactivate_tcq(sdev, sdev->queue_depth);
2423         } else
2424                 tag_type = 0;
2425
2426         return tag_type;
2427 }
2428
2429 static ssize_t ibmvfc_show_host_partition_name(struct device *dev,
2430                                                  struct device_attribute *attr, char *buf)
2431 {
2432         struct Scsi_Host *shost = class_to_shost(dev);
2433         struct ibmvfc_host *vhost = shost_priv(shost);
2434
2435         return snprintf(buf, PAGE_SIZE, "%s\n",
2436                         vhost->login_buf->resp.partition_name);
2437 }
2438
2439 static struct device_attribute ibmvfc_host_partition_name = {
2440         .attr = {
2441                 .name = "partition_name",
2442                 .mode = S_IRUGO,
2443         },
2444         .show = ibmvfc_show_host_partition_name,
2445 };
2446
2447 static ssize_t ibmvfc_show_host_device_name(struct device *dev,
2448                                             struct device_attribute *attr, char *buf)
2449 {
2450         struct Scsi_Host *shost = class_to_shost(dev);
2451         struct ibmvfc_host *vhost = shost_priv(shost);
2452
2453         return snprintf(buf, PAGE_SIZE, "%s\n",
2454                         vhost->login_buf->resp.device_name);
2455 }
2456
2457 static struct device_attribute ibmvfc_host_device_name = {
2458         .attr = {
2459                 .name = "device_name",
2460                 .mode = S_IRUGO,
2461         },
2462         .show = ibmvfc_show_host_device_name,
2463 };
2464
2465 static ssize_t ibmvfc_show_host_loc_code(struct device *dev,
2466                                          struct device_attribute *attr, char *buf)
2467 {
2468         struct Scsi_Host *shost = class_to_shost(dev);
2469         struct ibmvfc_host *vhost = shost_priv(shost);
2470
2471         return snprintf(buf, PAGE_SIZE, "%s\n",
2472                         vhost->login_buf->resp.port_loc_code);
2473 }
2474
2475 static struct device_attribute ibmvfc_host_loc_code = {
2476         .attr = {
2477                 .name = "port_loc_code",
2478                 .mode = S_IRUGO,
2479         },
2480         .show = ibmvfc_show_host_loc_code,
2481 };
2482
2483 static ssize_t ibmvfc_show_host_drc_name(struct device *dev,
2484                                          struct device_attribute *attr, char *buf)
2485 {
2486         struct Scsi_Host *shost = class_to_shost(dev);
2487         struct ibmvfc_host *vhost = shost_priv(shost);
2488
2489         return snprintf(buf, PAGE_SIZE, "%s\n",
2490                         vhost->login_buf->resp.drc_name);
2491 }
2492
2493 static struct device_attribute ibmvfc_host_drc_name = {
2494         .attr = {
2495                 .name = "drc_name",
2496                 .mode = S_IRUGO,
2497         },
2498         .show = ibmvfc_show_host_drc_name,
2499 };
2500
2501 static ssize_t ibmvfc_show_host_npiv_version(struct device *dev,
2502                                              struct device_attribute *attr, char *buf)
2503 {
2504         struct Scsi_Host *shost = class_to_shost(dev);
2505         struct ibmvfc_host *vhost = shost_priv(shost);
2506         return snprintf(buf, PAGE_SIZE, "%d\n", vhost->login_buf->resp.version);
2507 }
2508
2509 static struct device_attribute ibmvfc_host_npiv_version = {
2510         .attr = {
2511                 .name = "npiv_version",
2512                 .mode = S_IRUGO,
2513         },
2514         .show = ibmvfc_show_host_npiv_version,
2515 };
2516
2517 /**
2518  * ibmvfc_show_log_level - Show the adapter's error logging level
2519  * @dev:        class device struct
2520  * @buf:        buffer
2521  *
2522  * Return value:
2523  *      number of bytes printed to buffer
2524  **/
2525 static ssize_t ibmvfc_show_log_level(struct device *dev,
2526                                      struct device_attribute *attr, char *buf)
2527 {
2528         struct Scsi_Host *shost = class_to_shost(dev);
2529         struct ibmvfc_host *vhost = shost_priv(shost);
2530         unsigned long flags = 0;
2531         int len;
2532
2533         spin_lock_irqsave(shost->host_lock, flags);
2534         len = snprintf(buf, PAGE_SIZE, "%d\n", vhost->log_level);
2535         spin_unlock_irqrestore(shost->host_lock, flags);
2536         return len;
2537 }
2538
2539 /**
2540  * ibmvfc_store_log_level - Change the adapter's error logging level
2541  * @dev:        class device struct
2542  * @buf:        buffer
2543  *
2544  * Return value:
2545  *      number of bytes printed to buffer
2546  **/
2547 static ssize_t ibmvfc_store_log_level(struct device *dev,
2548                                       struct device_attribute *attr,
2549                                       const char *buf, size_t count)
2550 {
2551         struct Scsi_Host *shost = class_to_shost(dev);
2552         struct ibmvfc_host *vhost = shost_priv(shost);
2553         unsigned long flags = 0;
2554
2555         spin_lock_irqsave(shost->host_lock, flags);
2556         vhost->log_level = simple_strtoul(buf, NULL, 10);
2557         spin_unlock_irqrestore(shost->host_lock, flags);
2558         return strlen(buf);
2559 }
2560
2561 static struct device_attribute ibmvfc_log_level_attr = {
2562         .attr = {
2563                 .name =         "log_level",
2564                 .mode =         S_IRUGO | S_IWUSR,
2565         },
2566         .show = ibmvfc_show_log_level,
2567         .store = ibmvfc_store_log_level
2568 };
2569
2570 #ifdef CONFIG_SCSI_IBMVFC_TRACE
2571 /**
2572  * ibmvfc_read_trace - Dump the adapter trace
2573  * @kobj:               kobject struct
2574  * @bin_attr:   bin_attribute struct
2575  * @buf:                buffer
2576  * @off:                offset
2577  * @count:              buffer size
2578  *
2579  * Return value:
2580  *      number of bytes printed to buffer
2581  **/
2582 static ssize_t ibmvfc_read_trace(struct kobject *kobj,
2583                                  struct bin_attribute *bin_attr,
2584                                  char *buf, loff_t off, size_t count)
2585 {
2586         struct device *dev = container_of(kobj, struct device, kobj);
2587         struct Scsi_Host *shost = class_to_shost(dev);
2588         struct ibmvfc_host *vhost = shost_priv(shost);
2589         unsigned long flags = 0;
2590         int size = IBMVFC_TRACE_SIZE;
2591         char *src = (char *)vhost->trace;
2592
2593         if (off > size)
2594                 return 0;
2595         if (off + count > size) {
2596                 size -= off;
2597                 count = size;
2598         }
2599
2600         spin_lock_irqsave(shost->host_lock, flags);
2601         memcpy(buf, &src[off], count);
2602         spin_unlock_irqrestore(shost->host_lock, flags);
2603         return count;
2604 }
2605
2606 static struct bin_attribute ibmvfc_trace_attr = {
2607         .attr = {
2608                 .name = "trace",
2609                 .mode = S_IRUGO,
2610         },
2611         .size = 0,
2612         .read = ibmvfc_read_trace,
2613 };
2614 #endif
2615
2616 static struct device_attribute *ibmvfc_attrs[] = {
2617         &ibmvfc_host_partition_name,
2618         &ibmvfc_host_device_name,
2619         &ibmvfc_host_loc_code,
2620         &ibmvfc_host_drc_name,
2621         &ibmvfc_host_npiv_version,
2622         &ibmvfc_log_level_attr,
2623         NULL
2624 };
2625
2626 static struct scsi_host_template driver_template = {
2627         .module = THIS_MODULE,
2628         .name = "IBM POWER Virtual FC Adapter",
2629         .proc_name = IBMVFC_NAME,
2630         .queuecommand = ibmvfc_queuecommand,
2631         .eh_abort_handler = ibmvfc_eh_abort_handler,
2632         .eh_device_reset_handler = ibmvfc_eh_device_reset_handler,
2633         .eh_target_reset_handler = ibmvfc_eh_target_reset_handler,
2634         .eh_host_reset_handler = ibmvfc_eh_host_reset_handler,
2635         .slave_alloc = ibmvfc_slave_alloc,
2636         .slave_configure = ibmvfc_slave_configure,
2637         .target_alloc = ibmvfc_target_alloc,
2638         .scan_finished = ibmvfc_scan_finished,
2639         .change_queue_depth = ibmvfc_change_queue_depth,
2640         .change_queue_type = ibmvfc_change_queue_type,
2641         .cmd_per_lun = 16,
2642         .can_queue = IBMVFC_MAX_REQUESTS_DEFAULT,
2643         .this_id = -1,
2644         .sg_tablesize = SG_ALL,
2645         .max_sectors = IBMVFC_MAX_SECTORS,
2646         .use_clustering = ENABLE_CLUSTERING,
2647         .shost_attrs = ibmvfc_attrs,
2648 };
2649
2650 /**
2651  * ibmvfc_next_async_crq - Returns the next entry in async queue
2652  * @vhost:      ibmvfc host struct
2653  *
2654  * Returns:
2655  *      Pointer to next entry in queue / NULL if empty
2656  **/
2657 static struct ibmvfc_async_crq *ibmvfc_next_async_crq(struct ibmvfc_host *vhost)
2658 {
2659         struct ibmvfc_async_crq_queue *async_crq = &vhost->async_crq;
2660         struct ibmvfc_async_crq *crq;
2661
2662         crq = &async_crq->msgs[async_crq->cur];
2663         if (crq->valid & 0x80) {
2664                 if (++async_crq->cur == async_crq->size)
2665                         async_crq->cur = 0;
2666         } else
2667                 crq = NULL;
2668
2669         return crq;
2670 }
2671
2672 /**
2673  * ibmvfc_next_crq - Returns the next entry in message queue
2674  * @vhost:      ibmvfc host struct
2675  *
2676  * Returns:
2677  *      Pointer to next entry in queue / NULL if empty
2678  **/
2679 static struct ibmvfc_crq *ibmvfc_next_crq(struct ibmvfc_host *vhost)
2680 {
2681         struct ibmvfc_crq_queue *queue = &vhost->crq;
2682         struct ibmvfc_crq *crq;
2683
2684         crq = &queue->msgs[queue->cur];
2685         if (crq->valid & 0x80) {
2686                 if (++queue->cur == queue->size)
2687                         queue->cur = 0;
2688         } else
2689                 crq = NULL;
2690
2691         return crq;
2692 }
2693
2694 /**
2695  * ibmvfc_interrupt - Interrupt handler
2696  * @irq:                number of irq to handle, not used
2697  * @dev_instance: ibmvfc_host that received interrupt
2698  *
2699  * Returns:
2700  *      IRQ_HANDLED
2701  **/
2702 static irqreturn_t ibmvfc_interrupt(int irq, void *dev_instance)
2703 {
2704         struct ibmvfc_host *vhost = (struct ibmvfc_host *)dev_instance;
2705         struct vio_dev *vdev = to_vio_dev(vhost->dev);
2706         struct ibmvfc_crq *crq;
2707         struct ibmvfc_async_crq *async;
2708         unsigned long flags;
2709         int done = 0;
2710
2711         spin_lock_irqsave(vhost->host->host_lock, flags);
2712         vio_disable_interrupts(to_vio_dev(vhost->dev));
2713         while (!done) {
2714                 /* Pull all the valid messages off the CRQ */
2715                 while ((crq = ibmvfc_next_crq(vhost)) != NULL) {
2716                         ibmvfc_handle_crq(crq, vhost);
2717                         crq->valid = 0;
2718                 }
2719
2720                 /* Pull all the valid messages off the async CRQ */
2721                 while ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
2722                         ibmvfc_handle_async(async, vhost);
2723                         async->valid = 0;
2724                 }
2725
2726                 vio_enable_interrupts(vdev);
2727                 if ((crq = ibmvfc_next_crq(vhost)) != NULL) {
2728                         vio_disable_interrupts(vdev);
2729                         ibmvfc_handle_crq(crq, vhost);
2730                         crq->valid = 0;
2731                 } else if ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
2732                         vio_disable_interrupts(vdev);
2733                         ibmvfc_handle_async(async, vhost);
2734                         async->valid = 0;
2735                 } else
2736                         done = 1;
2737         }
2738
2739         spin_unlock_irqrestore(vhost->host->host_lock, flags);
2740         return IRQ_HANDLED;
2741 }
2742
2743 /**
2744  * ibmvfc_init_tgt - Set the next init job step for the target
2745  * @tgt:                ibmvfc target struct
2746  * @job_step:   job step to perform
2747  *
2748  **/
2749 static void ibmvfc_init_tgt(struct ibmvfc_target *tgt,
2750                             void (*job_step) (struct ibmvfc_target *))
2751 {
2752         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT);
2753         tgt->job_step = job_step;
2754         wake_up(&tgt->vhost->work_wait_q);
2755 }
2756
2757 /**
2758  * ibmvfc_retry_tgt_init - Attempt to retry a step in target initialization
2759  * @tgt:                ibmvfc target struct
2760  * @job_step:   initialization job step
2761  *
2762  **/
2763 static void ibmvfc_retry_tgt_init(struct ibmvfc_target *tgt,
2764                                   void (*job_step) (struct ibmvfc_target *))
2765 {
2766         if (++tgt->init_retries > IBMVFC_MAX_TGT_INIT_RETRIES) {
2767                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
2768                 wake_up(&tgt->vhost->work_wait_q);
2769         } else
2770                 ibmvfc_init_tgt(tgt, job_step);
2771 }
2772
2773 /**
2774  * ibmvfc_tgt_prli_done - Completion handler for Process Login
2775  * @evt:        ibmvfc event struct
2776  *
2777  **/
2778 static void ibmvfc_tgt_prli_done(struct ibmvfc_event *evt)
2779 {
2780         struct ibmvfc_target *tgt = evt->tgt;
2781         struct ibmvfc_host *vhost = evt->vhost;
2782         struct ibmvfc_process_login *rsp = &evt->xfer_iu->prli;
2783         u32 status = rsp->common.status;
2784
2785         vhost->discovery_threads--;
2786         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
2787         switch (status) {
2788         case IBMVFC_MAD_SUCCESS:
2789                 tgt_dbg(tgt, "Process Login succeeded\n");
2790                 tgt->need_login = 0;
2791                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_ADD_RPORT);
2792                 break;
2793         case IBMVFC_MAD_DRIVER_FAILED:
2794                 break;
2795         case IBMVFC_MAD_CRQ_ERROR:
2796                 ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
2797                 break;
2798         case IBMVFC_MAD_FAILED:
2799         default:
2800                 tgt_err(tgt, "Process Login failed: %s (%x:%x) rc=0x%02X\n",
2801                         ibmvfc_get_cmd_error(rsp->status, rsp->error),
2802                         rsp->status, rsp->error, status);
2803                 if (ibmvfc_retry_cmd(rsp->status, rsp->error))
2804                         ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
2805                 else
2806                         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
2807                 break;
2808         };
2809
2810         kref_put(&tgt->kref, ibmvfc_release_tgt);
2811         ibmvfc_free_event(evt);
2812         wake_up(&vhost->work_wait_q);
2813 }
2814
2815 /**
2816  * ibmvfc_tgt_send_prli - Send a process login
2817  * @tgt:        ibmvfc target struct
2818  *
2819  **/
2820 static void ibmvfc_tgt_send_prli(struct ibmvfc_target *tgt)
2821 {
2822         struct ibmvfc_process_login *prli;
2823         struct ibmvfc_host *vhost = tgt->vhost;
2824         struct ibmvfc_event *evt;
2825
2826         if (vhost->discovery_threads >= disc_threads)
2827                 return;
2828
2829         kref_get(&tgt->kref);
2830         evt = ibmvfc_get_event(vhost);
2831         vhost->discovery_threads++;
2832         ibmvfc_init_event(evt, ibmvfc_tgt_prli_done, IBMVFC_MAD_FORMAT);
2833         evt->tgt = tgt;
2834         prli = &evt->iu.prli;
2835         memset(prli, 0, sizeof(*prli));
2836         prli->common.version = 1;
2837         prli->common.opcode = IBMVFC_PROCESS_LOGIN;
2838         prli->common.length = sizeof(*prli);
2839         prli->scsi_id = tgt->scsi_id;
2840
2841         prli->parms.type = IBMVFC_SCSI_FCP_TYPE;
2842         prli->parms.flags = IBMVFC_PRLI_EST_IMG_PAIR;
2843         prli->parms.service_parms = IBMVFC_PRLI_INITIATOR_FUNC;
2844
2845         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
2846         if (ibmvfc_send_event(evt, vhost, default_timeout)) {
2847                 vhost->discovery_threads--;
2848                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
2849                 kref_put(&tgt->kref, ibmvfc_release_tgt);
2850         } else
2851                 tgt_dbg(tgt, "Sent process login\n");
2852 }
2853
2854 /**
2855  * ibmvfc_tgt_plogi_done - Completion handler for Port Login
2856  * @evt:        ibmvfc event struct
2857  *
2858  **/
2859 static void ibmvfc_tgt_plogi_done(struct ibmvfc_event *evt)
2860 {
2861         struct ibmvfc_target *tgt = evt->tgt;
2862         struct ibmvfc_host *vhost = evt->vhost;
2863         struct ibmvfc_port_login *rsp = &evt->xfer_iu->plogi;
2864         u32 status = rsp->common.status;
2865
2866         vhost->discovery_threads--;
2867         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
2868         switch (status) {
2869         case IBMVFC_MAD_SUCCESS:
2870                 tgt_dbg(tgt, "Port Login succeeded\n");
2871                 if (tgt->ids.port_name &&
2872                     tgt->ids.port_name != wwn_to_u64(rsp->service_parms.port_name)) {
2873                         vhost->reinit = 1;
2874                         tgt_dbg(tgt, "Port re-init required\n");
2875                         break;
2876                 }
2877                 tgt->ids.node_name = wwn_to_u64(rsp->service_parms.node_name);
2878                 tgt->ids.port_name = wwn_to_u64(rsp->service_parms.port_name);
2879                 tgt->ids.port_id = tgt->scsi_id;
2880                 tgt->ids.roles = FC_PORT_ROLE_FCP_TARGET;
2881                 memcpy(&tgt->service_parms, &rsp->service_parms,
2882                        sizeof(tgt->service_parms));
2883                 memcpy(&tgt->service_parms_change, &rsp->service_parms_change,
2884                        sizeof(tgt->service_parms_change));
2885                 ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_prli);
2886                 break;
2887         case IBMVFC_MAD_DRIVER_FAILED:
2888                 break;
2889         case IBMVFC_MAD_CRQ_ERROR:
2890                 ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
2891                 break;
2892         case IBMVFC_MAD_FAILED:
2893         default:
2894                 tgt_err(tgt, "Port Login failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
2895                         ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error,
2896                         ibmvfc_get_fc_type(rsp->fc_type), rsp->fc_type,
2897                         ibmvfc_get_ls_explain(rsp->fc_explain), rsp->fc_explain, status);
2898
2899                 if (ibmvfc_retry_cmd(rsp->status, rsp->error))
2900                         ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
2901                 else
2902                         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
2903                 break;
2904         };
2905
2906         kref_put(&tgt->kref, ibmvfc_release_tgt);
2907         ibmvfc_free_event(evt);
2908         wake_up(&vhost->work_wait_q);
2909 }
2910
2911 /**
2912  * ibmvfc_tgt_send_plogi - Send PLOGI to the specified target
2913  * @tgt:        ibmvfc target struct
2914  *
2915  **/
2916 static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *tgt)
2917 {
2918         struct ibmvfc_port_login *plogi;
2919         struct ibmvfc_host *vhost = tgt->vhost;
2920         struct ibmvfc_event *evt;
2921
2922         if (vhost->discovery_threads >= disc_threads)
2923                 return;
2924
2925         kref_get(&tgt->kref);
2926         evt = ibmvfc_get_event(vhost);
2927         vhost->discovery_threads++;
2928         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
2929         ibmvfc_init_event(evt, ibmvfc_tgt_plogi_done, IBMVFC_MAD_FORMAT);
2930         evt->tgt = tgt;
2931         plogi = &evt->iu.plogi;
2932         memset(plogi, 0, sizeof(*plogi));
2933         plogi->common.version = 1;
2934         plogi->common.opcode = IBMVFC_PORT_LOGIN;
2935         plogi->common.length = sizeof(*plogi);
2936         plogi->scsi_id = tgt->scsi_id;
2937
2938         if (ibmvfc_send_event(evt, vhost, default_timeout)) {
2939                 vhost->discovery_threads--;
2940                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
2941                 kref_put(&tgt->kref, ibmvfc_release_tgt);
2942         } else
2943                 tgt_dbg(tgt, "Sent port login\n");
2944 }
2945
2946 /**
2947  * ibmvfc_tgt_implicit_logout_done - Completion handler for Implicit Logout MAD
2948  * @evt:        ibmvfc event struct
2949  *
2950  **/
2951 static void ibmvfc_tgt_implicit_logout_done(struct ibmvfc_event *evt)
2952 {
2953         struct ibmvfc_target *tgt = evt->tgt;
2954         struct ibmvfc_host *vhost = evt->vhost;
2955         struct ibmvfc_implicit_logout *rsp = &evt->xfer_iu->implicit_logout;
2956         u32 status = rsp->common.status;
2957
2958         vhost->discovery_threads--;
2959         ibmvfc_free_event(evt);
2960         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
2961
2962         switch (status) {
2963         case IBMVFC_MAD_SUCCESS:
2964                 tgt_dbg(tgt, "Implicit Logout succeeded\n");
2965                 break;
2966         case IBMVFC_MAD_DRIVER_FAILED:
2967                 kref_put(&tgt->kref, ibmvfc_release_tgt);
2968                 wake_up(&vhost->work_wait_q);
2969                 return;
2970         case IBMVFC_MAD_FAILED:
2971         default:
2972                 tgt_err(tgt, "Implicit Logout failed: rc=0x%02X\n", status);
2973                 break;
2974         };
2975
2976         if (vhost->action == IBMVFC_HOST_ACTION_TGT_INIT)
2977                 ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_plogi);
2978         else if (vhost->action == IBMVFC_HOST_ACTION_QUERY_TGTS &&
2979                  tgt->scsi_id != tgt->new_scsi_id)
2980                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
2981         kref_put(&tgt->kref, ibmvfc_release_tgt);
2982         wake_up(&vhost->work_wait_q);
2983 }
2984
2985 /**
2986  * ibmvfc_tgt_implicit_logout - Initiate an Implicit Logout for specified target
2987  * @tgt:                ibmvfc target struct
2988  *
2989  **/
2990 static void ibmvfc_tgt_implicit_logout(struct ibmvfc_target *tgt)
2991 {
2992         struct ibmvfc_implicit_logout *mad;
2993         struct ibmvfc_host *vhost = tgt->vhost;
2994         struct ibmvfc_event *evt;
2995
2996         if (vhost->discovery_threads >= disc_threads)
2997                 return;
2998
2999         kref_get(&tgt->kref);
3000         evt = ibmvfc_get_event(vhost);
3001         vhost->discovery_threads++;
3002         ibmvfc_init_event(evt, ibmvfc_tgt_implicit_logout_done, IBMVFC_MAD_FORMAT);
3003         evt->tgt = tgt;
3004         mad = &evt->iu.implicit_logout;
3005         memset(mad, 0, sizeof(*mad));
3006         mad->common.version = 1;
3007         mad->common.opcode = IBMVFC_IMPLICIT_LOGOUT;
3008         mad->common.length = sizeof(*mad);
3009         mad->old_scsi_id = tgt->scsi_id;
3010
3011         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
3012         if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3013                 vhost->discovery_threads--;
3014                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3015                 kref_put(&tgt->kref, ibmvfc_release_tgt);
3016         } else
3017                 tgt_dbg(tgt, "Sent Implicit Logout\n");
3018 }
3019
3020 /**
3021  * ibmvfc_adisc_needs_plogi - Does device need PLOGI?
3022  * @mad:        ibmvfc passthru mad struct
3023  * @tgt:        ibmvfc target struct
3024  *
3025  * Returns:
3026  *      1 if PLOGI needed / 0 if PLOGI not needed
3027  **/
3028 static int ibmvfc_adisc_needs_plogi(struct ibmvfc_passthru_mad *mad,
3029                                     struct ibmvfc_target *tgt)
3030 {
3031         if (memcmp(&mad->fc_iu.response[2], &tgt->ids.port_name,
3032                    sizeof(tgt->ids.port_name)))
3033                 return 1;
3034         if (memcmp(&mad->fc_iu.response[4], &tgt->ids.node_name,
3035                    sizeof(tgt->ids.node_name)))
3036                 return 1;
3037         if (mad->fc_iu.response[6] != tgt->scsi_id)
3038                 return 1;
3039         return 0;
3040 }
3041
3042 /**
3043  * ibmvfc_tgt_adisc_done - Completion handler for ADISC
3044  * @evt:        ibmvfc event struct
3045  *
3046  **/
3047 static void ibmvfc_tgt_adisc_done(struct ibmvfc_event *evt)
3048 {
3049         struct ibmvfc_target *tgt = evt->tgt;
3050         struct ibmvfc_host *vhost = evt->vhost;
3051         struct ibmvfc_passthru_mad *mad = &evt->xfer_iu->passthru;
3052         u32 status = mad->common.status;
3053         u8 fc_reason, fc_explain;
3054
3055         vhost->discovery_threads--;
3056         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3057
3058         switch (status) {
3059         case IBMVFC_MAD_SUCCESS:
3060                 tgt_dbg(tgt, "ADISC succeeded\n");
3061                 if (ibmvfc_adisc_needs_plogi(mad, tgt))
3062                         tgt->need_login = 1;
3063                 break;
3064         case IBMVFC_MAD_DRIVER_FAILED:
3065                 break;
3066         case IBMVFC_MAD_FAILED:
3067         default:
3068                 tgt->need_login = 1;
3069                 fc_reason = (mad->fc_iu.response[1] & 0x00ff0000) >> 16;
3070                 fc_explain = (mad->fc_iu.response[1] & 0x0000ff00) >> 8;
3071                 tgt_info(tgt, "ADISC failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
3072                          ibmvfc_get_cmd_error(mad->iu.status, mad->iu.error),
3073                          mad->iu.status, mad->iu.error,
3074                          ibmvfc_get_fc_type(fc_reason), fc_reason,
3075                          ibmvfc_get_ls_explain(fc_explain), fc_explain, status);
3076                 break;
3077         };
3078
3079         kref_put(&tgt->kref, ibmvfc_release_tgt);
3080         ibmvfc_free_event(evt);
3081         wake_up(&vhost->work_wait_q);
3082 }
3083
3084 /**
3085  * ibmvfc_init_passthru - Initialize an event struct for FC passthru
3086  * @evt:                ibmvfc event struct
3087  *
3088  **/
3089 static void ibmvfc_init_passthru(struct ibmvfc_event *evt)
3090 {
3091         struct ibmvfc_passthru_mad *mad = &evt->iu.passthru;
3092
3093         memset(mad, 0, sizeof(*mad));
3094         mad->common.version = 1;
3095         mad->common.opcode = IBMVFC_PASSTHRU;
3096         mad->common.length = sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu);
3097         mad->cmd_ioba.va = (u64)evt->crq.ioba +
3098                 offsetof(struct ibmvfc_passthru_mad, iu);
3099         mad->cmd_ioba.len = sizeof(mad->iu);
3100         mad->iu.cmd_len = sizeof(mad->fc_iu.payload);
3101         mad->iu.rsp_len = sizeof(mad->fc_iu.response);
3102         mad->iu.cmd.va = (u64)evt->crq.ioba +
3103                 offsetof(struct ibmvfc_passthru_mad, fc_iu) +
3104                 offsetof(struct ibmvfc_passthru_fc_iu, payload);
3105         mad->iu.cmd.len = sizeof(mad->fc_iu.payload);
3106         mad->iu.rsp.va = (u64)evt->crq.ioba +
3107                 offsetof(struct ibmvfc_passthru_mad, fc_iu) +
3108                 offsetof(struct ibmvfc_passthru_fc_iu, response);
3109         mad->iu.rsp.len = sizeof(mad->fc_iu.response);
3110 }
3111
3112 /**
3113  * ibmvfc_tgt_adisc - Initiate an ADISC for specified target
3114  * @tgt:                ibmvfc target struct
3115  *
3116  **/
3117 static void ibmvfc_tgt_adisc(struct ibmvfc_target *tgt)
3118 {
3119         struct ibmvfc_passthru_mad *mad;
3120         struct ibmvfc_host *vhost = tgt->vhost;
3121         struct ibmvfc_event *evt;
3122
3123         if (vhost->discovery_threads >= disc_threads)
3124                 return;
3125
3126         kref_get(&tgt->kref);
3127         evt = ibmvfc_get_event(vhost);
3128         vhost->discovery_threads++;
3129         ibmvfc_init_event(evt, ibmvfc_tgt_adisc_done, IBMVFC_MAD_FORMAT);
3130         evt->tgt = tgt;
3131
3132         ibmvfc_init_passthru(evt);
3133         mad = &evt->iu.passthru;
3134         mad->iu.flags = IBMVFC_FC_ELS;
3135         mad->iu.scsi_id = tgt->scsi_id;
3136
3137         mad->fc_iu.payload[0] = IBMVFC_ADISC;
3138         memcpy(&mad->fc_iu.payload[2], &vhost->login_buf->resp.port_name,
3139                sizeof(vhost->login_buf->resp.port_name));
3140         memcpy(&mad->fc_iu.payload[4], &vhost->login_buf->resp.node_name,
3141                sizeof(vhost->login_buf->resp.node_name));
3142         mad->fc_iu.payload[6] = vhost->login_buf->resp.scsi_id & 0x00ffffff;
3143
3144         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
3145         if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3146                 vhost->discovery_threads--;
3147                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3148                 kref_put(&tgt->kref, ibmvfc_release_tgt);
3149         } else
3150                 tgt_dbg(tgt, "Sent ADISC\n");
3151 }
3152
3153 /**
3154  * ibmvfc_tgt_query_target_done - Completion handler for Query Target MAD
3155  * @evt:        ibmvfc event struct
3156  *
3157  **/
3158 static void ibmvfc_tgt_query_target_done(struct ibmvfc_event *evt)
3159 {
3160         struct ibmvfc_target *tgt = evt->tgt;
3161         struct ibmvfc_host *vhost = evt->vhost;
3162         struct ibmvfc_query_tgt *rsp = &evt->xfer_iu->query_tgt;
3163         u32 status = rsp->common.status;
3164
3165         vhost->discovery_threads--;
3166         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3167         switch (status) {
3168         case IBMVFC_MAD_SUCCESS:
3169                 tgt_dbg(tgt, "Query Target succeeded\n");
3170                 tgt->new_scsi_id = rsp->scsi_id;
3171                 if (rsp->scsi_id != tgt->scsi_id)
3172                         ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
3173                 else
3174                         ibmvfc_init_tgt(tgt, ibmvfc_tgt_adisc);
3175                 break;
3176         case IBMVFC_MAD_DRIVER_FAILED:
3177                 break;
3178         case IBMVFC_MAD_CRQ_ERROR:
3179                 ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
3180                 break;
3181         case IBMVFC_MAD_FAILED:
3182         default:
3183                 tgt_err(tgt, "Query Target failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
3184                         ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error,
3185                         ibmvfc_get_fc_type(rsp->fc_type), rsp->fc_type,
3186                         ibmvfc_get_gs_explain(rsp->fc_explain), rsp->fc_explain, status);
3187
3188                 if ((rsp->status & IBMVFC_FABRIC_MAPPED) == IBMVFC_FABRIC_MAPPED &&
3189                     rsp->error == IBMVFC_UNABLE_TO_PERFORM_REQ &&
3190                     rsp->fc_explain == IBMVFC_PORT_NAME_NOT_REG)
3191                         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
3192                 else if (ibmvfc_retry_cmd(rsp->status, rsp->error))
3193                         ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
3194                 else
3195                         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
3196                 break;
3197         };
3198
3199         kref_put(&tgt->kref, ibmvfc_release_tgt);
3200         ibmvfc_free_event(evt);
3201         wake_up(&vhost->work_wait_q);
3202 }
3203
3204 /**
3205  * ibmvfc_tgt_query_target - Initiate a Query Target for specified target
3206  * @tgt:        ibmvfc target struct
3207  *
3208  **/
3209 static void ibmvfc_tgt_query_target(struct ibmvfc_target *tgt)
3210 {
3211         struct ibmvfc_query_tgt *query_tgt;
3212         struct ibmvfc_host *vhost = tgt->vhost;
3213         struct ibmvfc_event *evt;
3214
3215         if (vhost->discovery_threads >= disc_threads)
3216                 return;
3217
3218         kref_get(&tgt->kref);
3219         evt = ibmvfc_get_event(vhost);
3220         vhost->discovery_threads++;
3221         evt->tgt = tgt;
3222         ibmvfc_init_event(evt, ibmvfc_tgt_query_target_done, IBMVFC_MAD_FORMAT);
3223         query_tgt = &evt->iu.query_tgt;
3224         memset(query_tgt, 0, sizeof(*query_tgt));
3225         query_tgt->common.version = 1;
3226         query_tgt->common.opcode = IBMVFC_QUERY_TARGET;
3227         query_tgt->common.length = sizeof(*query_tgt);
3228         query_tgt->wwpn = tgt->ids.port_name;
3229
3230         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
3231         if (ibmvfc_send_event(evt, vhost, default_timeout)) {
3232                 vhost->discovery_threads--;
3233                 ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3234                 kref_put(&tgt->kref, ibmvfc_release_tgt);
3235         } else
3236                 tgt_dbg(tgt, "Sent Query Target\n");
3237 }
3238
3239 /**
3240  * ibmvfc_alloc_target - Allocate and initialize an ibmvfc target
3241  * @vhost:              ibmvfc host struct
3242  * @scsi_id:    SCSI ID to allocate target for
3243  *
3244  * Returns:
3245  *      0 on success / other on failure
3246  **/
3247 static int ibmvfc_alloc_target(struct ibmvfc_host *vhost, u64 scsi_id)
3248 {
3249         struct ibmvfc_target *tgt;
3250         unsigned long flags;
3251
3252         spin_lock_irqsave(vhost->host->host_lock, flags);
3253         list_for_each_entry(tgt, &vhost->targets, queue) {
3254                 if (tgt->scsi_id == scsi_id) {
3255                         if (tgt->need_login)
3256                                 ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
3257                         goto unlock_out;
3258                 }
3259         }
3260         spin_unlock_irqrestore(vhost->host->host_lock, flags);
3261
3262         tgt = mempool_alloc(vhost->tgt_pool, GFP_KERNEL);
3263         if (!tgt) {
3264                 dev_err(vhost->dev, "Target allocation failure for scsi id %08llx\n",
3265                         scsi_id);
3266                 return -ENOMEM;
3267         }
3268
3269         tgt->scsi_id = scsi_id;
3270         tgt->new_scsi_id = scsi_id;
3271         tgt->vhost = vhost;
3272         tgt->need_login = 1;
3273         kref_init(&tgt->kref);
3274         ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
3275         spin_lock_irqsave(vhost->host->host_lock, flags);
3276         list_add_tail(&tgt->queue, &vhost->targets);
3277
3278 unlock_out:
3279         spin_unlock_irqrestore(vhost->host->host_lock, flags);
3280         return 0;
3281 }
3282
3283 /**
3284  * ibmvfc_alloc_targets - Allocate and initialize ibmvfc targets
3285  * @vhost:              ibmvfc host struct
3286  *
3287  * Returns:
3288  *      0 on success / other on failure
3289  **/
3290 static int ibmvfc_alloc_targets(struct ibmvfc_host *vhost)
3291 {
3292         int i, rc;
3293
3294         for (i = 0, rc = 0; !rc && i < vhost->num_targets; i++)
3295                 rc = ibmvfc_alloc_target(vhost,
3296                                          vhost->disc_buf->scsi_id[i] & IBMVFC_DISC_TGT_SCSI_ID_MASK);
3297
3298         return rc;
3299 }
3300
3301 /**
3302  * ibmvfc_discover_targets_done - Completion handler for discover targets MAD
3303  * @evt:        ibmvfc event struct
3304  *
3305  **/
3306 static void ibmvfc_discover_targets_done(struct ibmvfc_event *evt)
3307 {
3308         struct ibmvfc_host *vhost = evt->vhost;
3309         struct ibmvfc_discover_targets *rsp = &evt->xfer_iu->discover_targets;
3310         u32 mad_status = rsp->common.status;
3311
3312         switch (mad_status) {
3313         case IBMVFC_MAD_SUCCESS:
3314                 ibmvfc_dbg(vhost, "Discover Targets succeeded\n");
3315                 vhost->num_targets = rsp->num_written;
3316                 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_ALLOC_TGTS);
3317                 break;
3318         case IBMVFC_MAD_FAILED:
3319                 dev_err(vhost->dev, "Discover Targets failed: %s (%x:%x)\n",
3320                         ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error);
3321                 ibmvfc_retry_host_init(vhost);
3322                 break;
3323         case IBMVFC_MAD_DRIVER_FAILED:
3324                 break;
3325         default:
3326                 dev_err(vhost->dev, "Invalid Discover Targets response: 0x%x\n", mad_status);
3327                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3328                 break;
3329         }
3330
3331         ibmvfc_free_event(evt);
3332         wake_up(&vhost->work_wait_q);
3333 }
3334
3335 /**
3336  * ibmvfc_discover_targets - Send Discover Targets MAD
3337  * @vhost:      ibmvfc host struct
3338  *
3339  **/
3340 static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)
3341 {
3342         struct ibmvfc_discover_targets *mad;
3343         struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
3344
3345         ibmvfc_init_event(evt, ibmvfc_discover_targets_done, IBMVFC_MAD_FORMAT);
3346         mad = &evt->iu.discover_targets;
3347         memset(mad, 0, sizeof(*mad));
3348         mad->common.version = 1;
3349         mad->common.opcode = IBMVFC_DISC_TARGETS;
3350         mad->common.length = sizeof(*mad);
3351         mad->bufflen = vhost->disc_buf_sz;
3352         mad->buffer.va = vhost->disc_buf_dma;
3353         mad->buffer.len = vhost->disc_buf_sz;
3354         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
3355
3356         if (!ibmvfc_send_event(evt, vhost, default_timeout))
3357                 ibmvfc_dbg(vhost, "Sent discover targets\n");
3358         else
3359                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3360 }
3361
3362 /**
3363  * ibmvfc_npiv_login_done - Completion handler for NPIV Login
3364  * @evt:        ibmvfc event struct
3365  *
3366  **/
3367 static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
3368 {
3369         struct ibmvfc_host *vhost = evt->vhost;
3370         u32 mad_status = evt->xfer_iu->npiv_login.common.status;
3371         struct ibmvfc_npiv_login_resp *rsp = &vhost->login_buf->resp;
3372         unsigned int npiv_max_sectors;
3373
3374         switch (mad_status) {
3375         case IBMVFC_MAD_SUCCESS:
3376                 ibmvfc_free_event(evt);
3377                 break;
3378         case IBMVFC_MAD_FAILED:
3379                 dev_err(vhost->dev, "NPIV Login failed: %s (%x:%x)\n",
3380                         ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error);
3381                 if (ibmvfc_retry_cmd(rsp->status, rsp->error))
3382                         ibmvfc_retry_host_init(vhost);
3383                 else
3384                         ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3385                 ibmvfc_free_event(evt);
3386                 return;
3387         case IBMVFC_MAD_CRQ_ERROR:
3388                 ibmvfc_retry_host_init(vhost);
3389         case IBMVFC_MAD_DRIVER_FAILED:
3390                 ibmvfc_free_event(evt);
3391                 return;
3392         default:
3393                 dev_err(vhost->dev, "Invalid NPIV Login response: 0x%x\n", mad_status);
3394                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3395                 ibmvfc_free_event(evt);
3396                 return;
3397         }
3398
3399         vhost->client_migrated = 0;
3400
3401         if (!(rsp->flags & IBMVFC_NATIVE_FC)) {
3402                 dev_err(vhost->dev, "Virtual adapter does not support FC. %x\n",
3403                         rsp->flags);
3404                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3405                 wake_up(&vhost->work_wait_q);
3406                 return;
3407         }
3408
3409         if (rsp->max_cmds <= IBMVFC_NUM_INTERNAL_REQ) {
3410                 dev_err(vhost->dev, "Virtual adapter supported queue depth too small: %d\n",
3411                         rsp->max_cmds);
3412                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3413                 wake_up(&vhost->work_wait_q);
3414                 return;
3415         }
3416
3417         npiv_max_sectors = min((uint)(rsp->max_dma_len >> 9), IBMVFC_MAX_SECTORS);
3418         dev_info(vhost->dev, "Host partition: %s, device: %s %s %s max sectors %u\n",
3419                  rsp->partition_name, rsp->device_name, rsp->port_loc_code,
3420                  rsp->drc_name, npiv_max_sectors);
3421
3422         fc_host_fabric_name(vhost->host) = rsp->node_name;
3423         fc_host_node_name(vhost->host) = rsp->node_name;
3424         fc_host_port_name(vhost->host) = rsp->port_name;
3425         fc_host_port_id(vhost->host) = rsp->scsi_id;
3426         fc_host_port_type(vhost->host) = FC_PORTTYPE_NPIV;
3427         fc_host_supported_classes(vhost->host) = 0;
3428         if (rsp->service_parms.class1_parms[0] & 0x80000000)
3429                 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS1;
3430         if (rsp->service_parms.class2_parms[0] & 0x80000000)
3431                 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS2;
3432         if (rsp->service_parms.class3_parms[0] & 0x80000000)
3433                 fc_host_supported_classes(vhost->host) |= FC_COS_CLASS3;
3434         fc_host_maxframe_size(vhost->host) =
3435                 rsp->service_parms.common.bb_rcv_sz & 0x0fff;
3436
3437         vhost->host->can_queue = rsp->max_cmds - IBMVFC_NUM_INTERNAL_REQ;
3438         vhost->host->max_sectors = npiv_max_sectors;
3439         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
3440         wake_up(&vhost->work_wait_q);
3441 }
3442
3443 /**
3444  * ibmvfc_npiv_login - Sends NPIV login
3445  * @vhost:      ibmvfc host struct
3446  *
3447  **/
3448 static void ibmvfc_npiv_login(struct ibmvfc_host *vhost)
3449 {
3450         struct ibmvfc_npiv_login_mad *mad;
3451         struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
3452
3453         ibmvfc_gather_partition_info(vhost);
3454         ibmvfc_set_login_info(vhost);
3455         ibmvfc_init_event(evt, ibmvfc_npiv_login_done, IBMVFC_MAD_FORMAT);
3456
3457         memcpy(vhost->login_buf, &vhost->login_info, sizeof(vhost->login_info));
3458         mad = &evt->iu.npiv_login;
3459         memset(mad, 0, sizeof(struct ibmvfc_npiv_login_mad));
3460         mad->common.version = 1;
3461         mad->common.opcode = IBMVFC_NPIV_LOGIN;
3462         mad->common.length = sizeof(struct ibmvfc_npiv_login_mad);
3463         mad->buffer.va = vhost->login_buf_dma;
3464         mad->buffer.len = sizeof(*vhost->login_buf);
3465
3466         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
3467
3468         if (!ibmvfc_send_event(evt, vhost, default_timeout))
3469                 ibmvfc_dbg(vhost, "Sent NPIV login\n");
3470         else
3471                 ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
3472 };
3473
3474 /**
3475  * ibmvfc_dev_init_to_do - Is there target initialization work to do?
3476  * @vhost:              ibmvfc host struct
3477  *
3478  * Returns:
3479  *      1 if work to do / 0 if not
3480  **/
3481 static int ibmvfc_dev_init_to_do(struct ibmvfc_host *vhost)
3482 {
3483         struct ibmvfc_target *tgt;
3484
3485         list_for_each_entry(tgt, &vhost->targets, queue) {
3486                 if (tgt->action == IBMVFC_TGT_ACTION_INIT ||
3487                     tgt->action == IBMVFC_TGT_ACTION_INIT_WAIT)
3488                         return 1;
3489         }
3490
3491         return 0;
3492 }
3493
3494 /**
3495  * __ibmvfc_work_to_do - Is there task level work to do? (no locking)
3496  * @vhost:              ibmvfc host struct
3497  *
3498  * Returns:
3499  *      1 if work to do / 0 if not
3500  **/
3501 static int __ibmvfc_work_to_do(struct ibmvfc_host *vhost)
3502 {
3503         struct ibmvfc_target *tgt;
3504
3505         if (kthread_should_stop())
3506                 return 1;
3507         switch (vhost->action) {
3508         case IBMVFC_HOST_ACTION_NONE:
3509         case IBMVFC_HOST_ACTION_INIT_WAIT:
3510                 return 0;
3511         case IBMVFC_HOST_ACTION_TGT_INIT:
3512         case IBMVFC_HOST_ACTION_QUERY_TGTS:
3513                 if (vhost->discovery_threads == disc_threads)
3514                         return 0;
3515                 list_for_each_entry(tgt, &vhost->targets, queue)
3516                         if (tgt->action == IBMVFC_TGT_ACTION_INIT)
3517                                 return 1;
3518                 list_for_each_entry(tgt, &vhost->targets, queue)
3519                         if (tgt->action == IBMVFC_TGT_ACTION_INIT_WAIT)
3520                                 return 0;
3521                 return 1;
3522         case IBMVFC_HOST_ACTION_INIT:
3523         case IBMVFC_HOST_ACTION_ALLOC_TGTS:
3524         case IBMVFC_HOST_ACTION_TGT_ADD:
3525         case IBMVFC_HOST_ACTION_TGT_DEL:
3526         case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
3527         case IBMVFC_HOST_ACTION_QUERY:
3528         default:
3529                 break;
3530         };
3531
3532         return 1;
3533 }
3534
3535 /**
3536  * ibmvfc_work_to_do - Is there task level work to do?
3537  * @vhost:              ibmvfc host struct
3538  *
3539  * Returns:
3540  *      1 if work to do / 0 if not
3541  **/
3542 static int ibmvfc_work_to_do(struct ibmvfc_host *vhost)
3543 {
3544         unsigned long flags;
3545         int rc;
3546
3547         spin_lock_irqsave(vhost->host->host_lock, flags);
3548         rc = __ibmvfc_work_to_do(vhost);
3549         spin_unlock_irqrestore(vhost->host->host_lock, flags);
3550         return rc;
3551 }
3552
3553 /**
3554  * ibmvfc_log_ae - Log async events if necessary
3555  * @vhost:              ibmvfc host struct
3556  * @events:             events to log
3557  *
3558  **/
3559 static void ibmvfc_log_ae(struct ibmvfc_host *vhost, int events)
3560 {
3561         if (events & IBMVFC_AE_RSCN)
3562                 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_RSCN, 0);
3563         if ((events & IBMVFC_AE_LINKDOWN) &&
3564             vhost->state >= IBMVFC_HALTED)
3565                 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKDOWN, 0);
3566         if ((events & IBMVFC_AE_LINKUP) &&
3567             vhost->state == IBMVFC_INITIALIZING)
3568                 fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKUP, 0);
3569 }
3570
3571 /**
3572  * ibmvfc_tgt_add_rport - Tell the FC transport about a new remote port
3573  * @tgt:                ibmvfc target struct
3574  *
3575  **/
3576 static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
3577 {
3578         struct ibmvfc_host *vhost = tgt->vhost;
3579         struct fc_rport *rport;
3580         unsigned long flags;
3581
3582         tgt_dbg(tgt, "Adding rport\n");
3583         rport = fc_remote_port_add(vhost->host, 0, &tgt->ids);
3584         spin_lock_irqsave(vhost->host->host_lock, flags);
3585         tgt->rport = rport;
3586         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
3587         if (rport) {
3588                 tgt_dbg(tgt, "rport add succeeded\n");
3589                 rport->maxframe_size = tgt->service_parms.common.bb_rcv_sz & 0x0fff;
3590                 rport->supported_classes = 0;
3591                 tgt->target_id = rport->scsi_target_id;
3592                 if (tgt->service_parms.class1_parms[0] & 0x80000000)
3593                         rport->supported_classes |= FC_COS_CLASS1;
3594                 if (tgt->service_parms.class2_parms[0] & 0x80000000)
3595                         rport->supported_classes |= FC_COS_CLASS2;
3596                 if (tgt->service_parms.class3_parms[0] & 0x80000000)
3597                         rport->supported_classes |= FC_COS_CLASS3;
3598         } else
3599                 tgt_dbg(tgt, "rport add failed\n");
3600         spin_unlock_irqrestore(vhost->host->host_lock, flags);
3601 }
3602
3603 /**
3604  * ibmvfc_do_work - Do task level work
3605  * @vhost:              ibmvfc host struct
3606  *
3607  **/
3608 static void ibmvfc_do_work(struct ibmvfc_host *vhost)
3609 {
3610         struct ibmvfc_target *tgt;
3611         unsigned long flags;
3612         struct fc_rport *rport;
3613
3614         ibmvfc_log_ae(vhost, vhost->events_to_log);
3615         spin_lock_irqsave(vhost->host->host_lock, flags);
3616         vhost->events_to_log = 0;
3617         switch (vhost->action) {
3618         case IBMVFC_HOST_ACTION_NONE:
3619         case IBMVFC_HOST_ACTION_INIT_WAIT:
3620                 break;
3621         case IBMVFC_HOST_ACTION_INIT:
3622                 BUG_ON(vhost->state != IBMVFC_INITIALIZING);
3623                 if (vhost->delay_init) {
3624                         vhost->delay_init = 0;
3625                         spin_unlock_irqrestore(vhost->host->host_lock, flags);
3626                         ssleep(15);
3627                         return;
3628                 } else
3629                         vhost->job_step(vhost);
3630                 break;
3631         case IBMVFC_HOST_ACTION_QUERY:
3632                 list_for_each_entry(tgt, &vhost->targets, queue)
3633                         ibmvfc_init_tgt(tgt, ibmvfc_tgt_query_target);
3634                 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY_TGTS);
3635                 break;
3636         case IBMVFC_HOST_ACTION_QUERY_TGTS:
3637                 list_for_each_entry(tgt, &vhost->targets, queue) {
3638                         if (tgt->action == IBMVFC_TGT_ACTION_INIT) {
3639                                 tgt->job_step(tgt);
3640                                 break;
3641                         }
3642                 }
3643
3644                 if (!ibmvfc_dev_init_to_do(vhost))
3645                         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
3646                 break;
3647         case IBMVFC_HOST_ACTION_TGT_DEL:
3648         case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
3649                 list_for_each_entry(tgt, &vhost->targets, queue) {
3650                         if (tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
3651                                 tgt_dbg(tgt, "Deleting rport\n");
3652                                 rport = tgt->rport;
3653                                 tgt->rport = NULL;
3654                                 list_del(&tgt->queue);
3655                                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3656                                 if (rport)
3657                                         fc_remote_port_delete(rport);
3658                                 kref_put(&tgt->kref, ibmvfc_release_tgt);
3659                                 return;
3660                         }
3661                 }
3662
3663                 if (vhost->state == IBMVFC_INITIALIZING) {
3664                         if (vhost->action == IBMVFC_HOST_ACTION_TGT_DEL_FAILED) {
3665                                 ibmvfc_set_host_state(vhost, IBMVFC_ACTIVE);
3666                                 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_ADD);
3667                                 vhost->init_retries = 0;
3668                                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3669                                 scsi_unblock_requests(vhost->host);
3670                                 return;
3671                         } else {
3672                                 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
3673                                 vhost->job_step = ibmvfc_discover_targets;
3674                         }
3675                 } else {
3676                         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
3677                         spin_unlock_irqrestore(vhost->host->host_lock, flags);
3678                         scsi_unblock_requests(vhost->host);
3679                         wake_up(&vhost->init_wait_q);
3680                         return;
3681                 }
3682                 break;
3683         case IBMVFC_HOST_ACTION_ALLOC_TGTS:
3684                 ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_INIT);
3685                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3686                 ibmvfc_alloc_targets(vhost);
3687                 spin_lock_irqsave(vhost->host->host_lock, flags);
3688                 break;
3689         case IBMVFC_HOST_ACTION_TGT_INIT:
3690                 list_for_each_entry(tgt, &vhost->targets, queue) {
3691                         if (tgt->action == IBMVFC_TGT_ACTION_INIT) {
3692                                 tgt->job_step(tgt);
3693                                 break;
3694                         }
3695                 }
3696
3697                 if (!ibmvfc_dev_init_to_do(vhost))
3698                         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL_FAILED);
3699                 break;
3700         case IBMVFC_HOST_ACTION_TGT_ADD:
3701                 list_for_each_entry(tgt, &vhost->targets, queue) {
3702                         if (tgt->action == IBMVFC_TGT_ACTION_ADD_RPORT) {
3703                                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
3704                                 ibmvfc_tgt_add_rport(tgt);
3705                                 return;
3706                         }
3707                 }
3708
3709                 if (vhost->reinit && !ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
3710                         vhost->reinit = 0;
3711                         scsi_block_requests(vhost->host);
3712                         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
3713                 } else {
3714                         ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
3715                         wake_up(&vhost->init_wait_q);
3716                 }
3717                 break;
3718         default:
3719                 break;
3720         };
3721
3722         spin_unlock_irqrestore(vhost->host->host_lock, flags);
3723 }
3724
3725 /**
3726  * ibmvfc_work - Do task level work
3727  * @data:               ibmvfc host struct
3728  *
3729  * Returns:
3730  *      zero
3731  **/
3732 static int ibmvfc_work(void *data)
3733 {
3734         struct ibmvfc_host *vhost = data;
3735         int rc;
3736
3737         set_user_nice(current, -20);
3738
3739         while (1) {
3740                 rc = wait_event_interruptible(vhost->work_wait_q,
3741                                               ibmvfc_work_to_do(vhost));
3742
3743                 BUG_ON(rc);
3744
3745                 if (kthread_should_stop())
3746                         break;
3747
3748                 ibmvfc_do_work(vhost);
3749         }
3750
3751         ibmvfc_dbg(vhost, "ibmvfc kthread exiting...\n");
3752         return 0;
3753 }
3754
3755 /**
3756  * ibmvfc_init_crq - Initializes and registers CRQ with hypervisor
3757  * @vhost:      ibmvfc host struct
3758  *
3759  * Allocates a page for messages, maps it for dma, and registers
3760  * the crq with the hypervisor.
3761  *
3762  * Return value:
3763  *      zero on success / other on failure
3764  **/
3765 static int ibmvfc_init_crq(struct ibmvfc_host *vhost)
3766 {
3767         int rc, retrc = -ENOMEM;
3768         struct device *dev = vhost->dev;
3769         struct vio_dev *vdev = to_vio_dev(dev);
3770         struct ibmvfc_crq_queue *crq = &vhost->crq;
3771
3772         ENTER;
3773         crq->msgs = (struct ibmvfc_crq *)get_zeroed_page(GFP_KERNEL);
3774
3775         if (!crq->msgs)
3776                 return -ENOMEM;
3777
3778         crq->size = PAGE_SIZE / sizeof(*crq->msgs);
3779         crq->msg_token = dma_map_single(dev, crq->msgs,
3780                                         PAGE_SIZE, DMA_BIDIRECTIONAL);
3781
3782         if (dma_mapping_error(dev, crq->msg_token))
3783                 goto map_failed;
3784
3785         retrc = rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
3786                                         crq->msg_token, PAGE_SIZE);
3787
3788         if (rc == H_RESOURCE)
3789                 /* maybe kexecing and resource is busy. try a reset */
3790                 retrc = rc = ibmvfc_reset_crq(vhost);
3791
3792         if (rc == H_CLOSED)
3793                 dev_warn(dev, "Partner adapter not ready\n");
3794         else if (rc) {
3795                 dev_warn(dev, "Error %d opening adapter\n", rc);
3796                 goto reg_crq_failed;
3797         }
3798
3799         retrc = 0;
3800
3801         if ((rc = request_irq(vdev->irq, ibmvfc_interrupt, 0, IBMVFC_NAME, vhost))) {
3802                 dev_err(dev, "Couldn't register irq 0x%x. rc=%d\n", vdev->irq, rc);
3803                 goto req_irq_failed;
3804         }
3805
3806         if ((rc = vio_enable_interrupts(vdev))) {
3807                 dev_err(dev, "Error %d enabling interrupts\n", rc);
3808                 goto req_irq_failed;
3809         }
3810
3811         crq->cur = 0;
3812         LEAVE;
3813         return retrc;
3814
3815 req_irq_failed:
3816         do {
3817                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
3818         } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
3819 reg_crq_failed:
3820         dma_unmap_single(dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
3821 map_failed:
3822         free_page((unsigned long)crq->msgs);
3823         return retrc;
3824 }
3825
3826 /**
3827  * ibmvfc_free_mem - Free memory for vhost
3828  * @vhost:      ibmvfc host struct
3829  *
3830  * Return value:
3831  *      none
3832  **/
3833 static void ibmvfc_free_mem(struct ibmvfc_host *vhost)
3834 {
3835         struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
3836
3837         ENTER;
3838         mempool_destroy(vhost->tgt_pool);
3839         kfree(vhost->trace);
3840         dma_free_coherent(vhost->dev, vhost->disc_buf_sz, vhost->disc_buf,
3841                           vhost->disc_buf_dma);
3842         dma_free_coherent(vhost->dev, sizeof(*vhost->login_buf),
3843                           vhost->login_buf, vhost->login_buf_dma);
3844         dma_pool_destroy(vhost->sg_pool);
3845         dma_unmap_single(vhost->dev, async_q->msg_token,
3846                          async_q->size * sizeof(*async_q->msgs), DMA_BIDIRECTIONAL);
3847         free_page((unsigned long)async_q->msgs);
3848         LEAVE;
3849 }
3850
3851 /**
3852  * ibmvfc_alloc_mem - Allocate memory for vhost
3853  * @vhost:      ibmvfc host struct
3854  *
3855  * Return value:
3856  *      0 on success / non-zero on failure
3857  **/
3858 static int ibmvfc_alloc_mem(struct ibmvfc_host *vhost)
3859 {
3860         struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
3861         struct device *dev = vhost->dev;
3862
3863         ENTER;
3864         async_q->msgs = (struct ibmvfc_async_crq *)get_zeroed_page(GFP_KERNEL);
3865         if (!async_q->msgs) {
3866                 dev_err(dev, "Couldn't allocate async queue.\n");
3867                 goto nomem;
3868         }
3869
3870         async_q->size = PAGE_SIZE / sizeof(struct ibmvfc_async_crq);
3871         async_q->msg_token = dma_map_single(dev, async_q->msgs,
3872                                             async_q->size * sizeof(*async_q->msgs),
3873                                             DMA_BIDIRECTIONAL);
3874
3875         if (dma_mapping_error(dev, async_q->msg_token)) {
3876                 dev_err(dev, "Failed to map async queue\n");
3877                 goto free_async_crq;
3878         }
3879
3880         vhost->sg_pool = dma_pool_create(IBMVFC_NAME, dev,
3881                                          SG_ALL * sizeof(struct srp_direct_buf),
3882                                          sizeof(struct srp_direct_buf), 0);
3883
3884         if (!vhost->sg_pool) {
3885                 dev_err(dev, "Failed to allocate sg pool\n");
3886                 goto unmap_async_crq;
3887         }
3888
3889         vhost->login_buf = dma_alloc_coherent(dev, sizeof(*vhost->login_buf),
3890                                               &vhost->login_buf_dma, GFP_KERNEL);
3891
3892         if (!vhost->login_buf) {
3893                 dev_err(dev, "Couldn't allocate NPIV login buffer\n");
3894                 goto free_sg_pool;
3895         }
3896
3897         vhost->disc_buf_sz = sizeof(vhost->disc_buf->scsi_id[0]) * max_targets;
3898         vhost->disc_buf = dma_alloc_coherent(dev, vhost->disc_buf_sz,
3899                                              &vhost->disc_buf_dma, GFP_KERNEL);
3900
3901         if (!vhost->disc_buf) {
3902                 dev_err(dev, "Couldn't allocate Discover Targets buffer\n");
3903                 goto free_login_buffer;
3904         }
3905
3906         vhost->trace = kcalloc(IBMVFC_NUM_TRACE_ENTRIES,
3907                                sizeof(struct ibmvfc_trace_entry), GFP_KERNEL);
3908
3909         if (!vhost->trace)
3910                 goto free_disc_buffer;
3911
3912         vhost->tgt_pool = mempool_create_kzalloc_pool(IBMVFC_TGT_MEMPOOL_SZ,
3913                                                       sizeof(struct ibmvfc_target));
3914
3915         if (!vhost->tgt_pool) {
3916                 dev_err(dev, "Couldn't allocate target memory pool\n");
3917                 goto free_trace;
3918         }
3919
3920         LEAVE;
3921         return 0;
3922
3923 free_trace:
3924         kfree(vhost->trace);
3925 free_disc_buffer:
3926         dma_free_coherent(dev, vhost->disc_buf_sz, vhost->disc_buf,
3927                           vhost->disc_buf_dma);
3928 free_login_buffer:
3929         dma_free_coherent(dev, sizeof(*vhost->login_buf),
3930                           vhost->login_buf, vhost->login_buf_dma);
3931 free_sg_pool:
3932         dma_pool_destroy(vhost->sg_pool);
3933 unmap_async_crq:
3934         dma_unmap_single(dev, async_q->msg_token,
3935                          async_q->size * sizeof(*async_q->msgs), DMA_BIDIRECTIONAL);
3936 free_async_crq:
3937         free_page((unsigned long)async_q->msgs);
3938 nomem:
3939         LEAVE;
3940         return -ENOMEM;
3941 }
3942
3943 /**
3944  * ibmvfc_probe - Adapter hot plug add entry point
3945  * @vdev:       vio device struct
3946  * @id: vio device id struct
3947  *
3948  * Return value:
3949  *      0 on success / non-zero on failure
3950  **/
3951 static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
3952 {
3953         struct ibmvfc_host *vhost;
3954         struct Scsi_Host *shost;
3955         struct device *dev = &vdev->dev;
3956         int rc = -ENOMEM;
3957
3958         ENTER;
3959         shost = scsi_host_alloc(&driver_template, sizeof(*vhost));
3960         if (!shost) {
3961                 dev_err(dev, "Couldn't allocate host data\n");
3962                 goto out;
3963         }
3964
3965         shost->transportt = ibmvfc_transport_template;
3966         shost->can_queue = max_requests;
3967         shost->max_lun = max_lun;
3968         shost->max_id = max_targets;
3969         shost->max_sectors = IBMVFC_MAX_SECTORS;
3970         shost->max_cmd_len = IBMVFC_MAX_CDB_LEN;
3971         shost->unique_id = shost->host_no;
3972
3973         vhost = shost_priv(shost);
3974         INIT_LIST_HEAD(&vhost->sent);
3975         INIT_LIST_HEAD(&vhost->free);
3976         INIT_LIST_HEAD(&vhost->targets);
3977         sprintf(vhost->name, IBMVFC_NAME);
3978         vhost->host = shost;
3979         vhost->dev = dev;
3980         vhost->partition_number = -1;
3981         vhost->log_level = log_level;
3982         strcpy(vhost->partition_name, "UNKNOWN");
3983         init_waitqueue_head(&vhost->work_wait_q);
3984         init_waitqueue_head(&vhost->init_wait_q);
3985
3986         if ((rc = ibmvfc_alloc_mem(vhost)))
3987                 goto free_scsi_host;
3988
3989         vhost->work_thread = kthread_run(ibmvfc_work, vhost, "%s_%d", IBMVFC_NAME,
3990                                          shost->host_no);
3991
3992         if (IS_ERR(vhost->work_thread)) {
3993                 dev_err(dev, "Couldn't create kernel thread: %ld\n",
3994                         PTR_ERR(vhost->work_thread));
3995                 goto free_host_mem;
3996         }
3997
3998         if ((rc = ibmvfc_init_crq(vhost))) {
3999                 dev_err(dev, "Couldn't initialize crq. rc=%d\n", rc);
4000                 goto kill_kthread;
4001         }
4002
4003         if ((rc = ibmvfc_init_event_pool(vhost))) {
4004                 dev_err(dev, "Couldn't initialize event pool. rc=%d\n", rc);
4005                 goto release_crq;
4006         }
4007
4008         if ((rc = scsi_add_host(shost, dev)))
4009                 goto release_event_pool;
4010
4011         if ((rc = ibmvfc_create_trace_file(&shost->shost_dev.kobj,
4012                                            &ibmvfc_trace_attr))) {
4013                 dev_err(dev, "Failed to create trace file. rc=%d\n", rc);
4014                 goto remove_shost;
4015         }
4016
4017         dev_set_drvdata(dev, vhost);
4018         spin_lock(&ibmvfc_driver_lock);
4019         list_add_tail(&vhost->queue, &ibmvfc_head);
4020         spin_unlock(&ibmvfc_driver_lock);
4021
4022         ibmvfc_send_crq_init(vhost);
4023         scsi_scan_host(shost);
4024         return 0;
4025
4026 remove_shost:
4027         scsi_remove_host(shost);
4028 release_event_pool:
4029         ibmvfc_free_event_pool(vhost);
4030 release_crq:
4031         ibmvfc_release_crq_queue(vhost);
4032 kill_kthread:
4033         kthread_stop(vhost->work_thread);
4034 free_host_mem:
4035         ibmvfc_free_mem(vhost);
4036 free_scsi_host:
4037         scsi_host_put(shost);
4038 out:
4039         LEAVE;
4040         return rc;
4041 }
4042
4043 /**
4044  * ibmvfc_remove - Adapter hot plug remove entry point
4045  * @vdev:       vio device struct
4046  *
4047  * Return value:
4048  *      0
4049  **/
4050 static int ibmvfc_remove(struct vio_dev *vdev)
4051 {
4052         struct ibmvfc_host *vhost = dev_get_drvdata(&vdev->dev);
4053         unsigned long flags;
4054
4055         ENTER;
4056         ibmvfc_remove_trace_file(&vhost->host->shost_dev.kobj, &ibmvfc_trace_attr);
4057         ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
4058         ibmvfc_wait_while_resetting(vhost);
4059         ibmvfc_release_crq_queue(vhost);
4060         kthread_stop(vhost->work_thread);
4061         fc_remove_host(vhost->host);
4062         scsi_remove_host(vhost->host);
4063
4064         spin_lock_irqsave(vhost->host->host_lock, flags);
4065         ibmvfc_purge_requests(vhost, DID_ERROR);
4066         ibmvfc_free_event_pool(vhost);
4067         spin_unlock_irqrestore(vhost->host->host_lock, flags);
4068
4069         ibmvfc_free_mem(vhost);
4070         spin_lock(&ibmvfc_driver_lock);
4071         list_del(&vhost->queue);
4072         spin_unlock(&ibmvfc_driver_lock);
4073         scsi_host_put(vhost->host);
4074         LEAVE;
4075         return 0;
4076 }
4077
4078 /**
4079  * ibmvfc_get_desired_dma - Calculate DMA resources needed by the driver
4080  * @vdev:       vio device struct
4081  *
4082  * Return value:
4083  *      Number of bytes the driver will need to DMA map at the same time in
4084  *      order to perform well.
4085  */
4086 static unsigned long ibmvfc_get_desired_dma(struct vio_dev *vdev)
4087 {
4088         unsigned long pool_dma = max_requests * sizeof(union ibmvfc_iu);
4089         return pool_dma + ((512 * 1024) * driver_template.cmd_per_lun);
4090 }
4091
4092 static struct vio_device_id ibmvfc_device_table[] __devinitdata = {
4093         {"fcp", "IBM,vfc-client"},
4094         { "", "" }
4095 };
4096 MODULE_DEVICE_TABLE(vio, ibmvfc_device_table);
4097
4098 static struct vio_driver ibmvfc_driver = {
4099         .id_table = ibmvfc_device_table,
4100         .probe = ibmvfc_probe,
4101         .remove = ibmvfc_remove,
4102         .get_desired_dma = ibmvfc_get_desired_dma,
4103         .driver = {
4104                 .name = IBMVFC_NAME,
4105                 .owner = THIS_MODULE,
4106         }
4107 };
4108
4109 static struct fc_function_template ibmvfc_transport_functions = {
4110         .show_host_fabric_name = 1,
4111         .show_host_node_name = 1,
4112         .show_host_port_name = 1,
4113         .show_host_supported_classes = 1,
4114         .show_host_port_type = 1,
4115         .show_host_port_id = 1,
4116
4117         .get_host_port_state = ibmvfc_get_host_port_state,
4118         .show_host_port_state = 1,
4119
4120         .get_host_speed = ibmvfc_get_host_speed,
4121         .show_host_speed = 1,
4122
4123         .issue_fc_host_lip = ibmvfc_issue_fc_host_lip,
4124         .terminate_rport_io = ibmvfc_terminate_rport_io,
4125
4126         .show_rport_maxframe_size = 1,
4127         .show_rport_supported_classes = 1,
4128
4129         .set_rport_dev_loss_tmo = ibmvfc_set_rport_dev_loss_tmo,
4130         .show_rport_dev_loss_tmo = 1,
4131
4132         .get_starget_node_name = ibmvfc_get_starget_node_name,
4133         .show_starget_node_name = 1,
4134
4135         .get_starget_port_name = ibmvfc_get_starget_port_name,
4136         .show_starget_port_name = 1,
4137
4138         .get_starget_port_id = ibmvfc_get_starget_port_id,
4139         .show_starget_port_id = 1,
4140 };
4141
4142 /**
4143  * ibmvfc_module_init - Initialize the ibmvfc module
4144  *
4145  * Return value:
4146  *      0 on success / other on failure
4147  **/
4148 static int __init ibmvfc_module_init(void)
4149 {
4150         int rc;
4151
4152         if (!firmware_has_feature(FW_FEATURE_VIO))
4153                 return -ENODEV;
4154
4155         printk(KERN_INFO IBMVFC_NAME": IBM Virtual Fibre Channel Driver version: %s %s\n",
4156                IBMVFC_DRIVER_VERSION, IBMVFC_DRIVER_DATE);
4157
4158         ibmvfc_transport_template = fc_attach_transport(&ibmvfc_transport_functions);
4159         if (!ibmvfc_transport_template)
4160                 return -ENOMEM;
4161
4162         rc = vio_register_driver(&ibmvfc_driver);
4163         if (rc)
4164                 fc_release_transport(ibmvfc_transport_template);
4165         return rc;
4166 }
4167
4168 /**
4169  * ibmvfc_module_exit - Teardown the ibmvfc module
4170  *
4171  * Return value:
4172  *      nothing
4173  **/
4174 static void __exit ibmvfc_module_exit(void)
4175 {
4176         vio_unregister_driver(&ibmvfc_driver);
4177         fc_release_transport(ibmvfc_transport_template);
4178 }
4179
4180 module_init(ibmvfc_module_init);
4181 module_exit(ibmvfc_module_exit);