SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/s390/scsi/zfcp_fsf.c

   1 /*
   2  * zfcp device driver
   3  *
   4  * Implementation of FSF commands.
   5  *
   6  * Copyright IBM Corporation 2002, 2008
   7  */
   8
   9 #define KMSG_COMPONENT "zfcp"
  10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11
  12 #include <linux/blktrace_api.h>
  13 #include "zfcp_ext.h"
  14
  15 #define ZFCP_REQ_AUTO_CLEANUP   0x00000002
  16 #define ZFCP_REQ_NO_QTCB        0x00000008
  17
  18 static void zfcp_fsf_request_timeout_handler(unsigned long data)
  19 {
  20         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
  21         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
  22                                 "fsrth_1", NULL);
  23 }
  24
  25 static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
  26                                  unsigned long timeout)
  27 {
  28         fsf_req->timer.function = zfcp_fsf_request_timeout_handler;
  29         fsf_req->timer.data = (unsigned long) fsf_req->adapter;
  30         fsf_req->timer.expires = jiffies + timeout;
  31         add_timer(&fsf_req->timer);
  32 }
  33
  34 static void zfcp_fsf_start_erp_timer(struct zfcp_fsf_req *fsf_req)
  35 {
  36         BUG_ON(!fsf_req->erp_action);
  37         fsf_req->timer.function = zfcp_erp_timeout_handler;
  38         fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
  39         fsf_req->timer.expires = jiffies + 30 * HZ;
  40         add_timer(&fsf_req->timer);
  41 }
  42
  43 /* association between FSF command and FSF QTCB type */
  44 static u32 fsf_qtcb_type[] = {
  45         [FSF_QTCB_FCP_CMND] =             FSF_IO_COMMAND,
  46         [FSF_QTCB_ABORT_FCP_CMND] =       FSF_SUPPORT_COMMAND,
  47         [FSF_QTCB_OPEN_PORT_WITH_DID] =   FSF_SUPPORT_COMMAND,
  48         [FSF_QTCB_OPEN_LUN] =             FSF_SUPPORT_COMMAND,
  49         [FSF_QTCB_CLOSE_LUN] =            FSF_SUPPORT_COMMAND,
  50         [FSF_QTCB_CLOSE_PORT] =           FSF_SUPPORT_COMMAND,
  51         [FSF_QTCB_CLOSE_PHYSICAL_PORT] =  FSF_SUPPORT_COMMAND,
  52         [FSF_QTCB_SEND_ELS] =             FSF_SUPPORT_COMMAND,
  53         [FSF_QTCB_SEND_GENERIC] =         FSF_SUPPORT_COMMAND,
  54         [FSF_QTCB_EXCHANGE_CONFIG_DATA] = FSF_CONFIG_COMMAND,
  55         [FSF_QTCB_EXCHANGE_PORT_DATA] =   FSF_PORT_COMMAND,
  56         [FSF_QTCB_DOWNLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND,
  57         [FSF_QTCB_UPLOAD_CONTROL_FILE] =  FSF_SUPPORT_COMMAND
  58 };
  59
  60 static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
  61 {
  62         u16 subtable = table >> 16;
  63         u16 rule = table & 0xffff;
  64         const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" };
  65
  66         if (subtable && subtable < ARRAY_SIZE(act_type))
  67                 dev_warn(&adapter->ccw_device->dev,
  68                          "Access denied according to ACT rule type %s, "
  69                          "rule %d\n", act_type[subtable], rule);
  70 }
  71
  72 static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req,
  73                                         struct zfcp_port *port)
  74 {
  75         struct fsf_qtcb_header *header = &req->qtcb->header;
  76         dev_warn(&req->adapter->ccw_device->dev,
  77                  "Access denied to port 0x%016Lx\n",
  78                  (unsigned long long)port->wwpn);
  79         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
  80         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
  81         zfcp_erp_port_access_denied(port, "fspad_1", req);
  82         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  83 }
  84
  85 static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req *req,
  86                                         struct zfcp_unit *unit)
  87 {
  88         struct fsf_qtcb_header *header = &req->qtcb->header;
  89         dev_warn(&req->adapter->ccw_device->dev,
  90                  "Access denied to unit 0x%016Lx on port 0x%016Lx\n",
  91                  (unsigned long long)unit->fcp_lun,
  92                  (unsigned long long)unit->port->wwpn);
  93         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
  94         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
  95         zfcp_erp_unit_access_denied(unit, "fsuad_1", req);
  96         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
  97 }
  98
  99 static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
 100 {
 101         dev_err(&req->adapter->ccw_device->dev, "FCP device not "
 102                 "operational because of an unsupported FC class\n");
 103         zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1", req);
 104         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 105 }
 106
 107 /**
 108  * zfcp_fsf_req_free - free memory used by fsf request
 109  * @fsf_req: pointer to struct zfcp_fsf_req
 110  */
 111 void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
 112 {
 113         if (likely(req->pool)) {
 114                 mempool_free(req, req->pool);
 115                 return;
 116         }
 117
 118         if (req->qtcb) {
 119                 kmem_cache_free(zfcp_data.fsf_req_qtcb_cache, req);
 120                 return;
 121         }
 122 }
 123
 124 /**
 125  * zfcp_fsf_req_dismiss_all - dismiss all fsf requests
 126  * @adapter: pointer to struct zfcp_adapter
 127  *
 128  * Never ever call this without shutting down the adapter first.
 129  * Otherwise the adapter would continue using and corrupting s390 storage.
 130  * Included BUG_ON() call to ensure this is done.
 131  * ERP is supposed to be the only user of this function.
 132  */
 133 void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
 134 {
 135         struct zfcp_fsf_req *req, *tmp;
 136         unsigned long flags;
 137         LIST_HEAD(remove_queue);
 138         unsigned int i;
 139
 140         BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
 141         spin_lock_irqsave(&adapter->req_list_lock, flags);
 142         for (i = 0; i < REQUEST_LIST_SIZE; i++)
 143                 list_splice_init(&adapter->req_list[i], &remove_queue);
 144         spin_unlock_irqrestore(&adapter->req_list_lock, flags);
 145
 146         list_for_each_entry_safe(req, tmp, &remove_queue, list) {
 147                 list_del(&req->list);
 148                 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
 149                 zfcp_fsf_req_complete(req);
 150         }
 151 }
 152
 153 static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
 154 {
 155         struct fsf_status_read_buffer *sr_buf = req->data;
 156         struct zfcp_adapter *adapter = req->adapter;
 157         struct zfcp_port *port;
 158         int d_id = sr_buf->d_id & ZFCP_DID_MASK;
 159         unsigned long flags;
 160
 161         read_lock_irqsave(&zfcp_data.config_lock, flags);
 162         list_for_each_entry(port, &adapter->port_list_head, list)
 163                 if (port->d_id == d_id) {
 164                         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 165                         zfcp_erp_port_reopen(port, 0, "fssrpc1", req);
 166                         return;
 167                 }
 168         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 169 }
 170
 171 static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, char *id,
 172                                          struct fsf_link_down_info *link_down)
 173 {
 174         struct zfcp_adapter *adapter = req->adapter;
 175
 176         if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
 177                 return;
 178
 179         atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
 180
 181         if (!link_down)
 182                 goto out;
 183
 184         switch (link_down->error_code) {
 185         case FSF_PSQ_LINK_NO_LIGHT:
 186                 dev_warn(&req->adapter->ccw_device->dev,
 187                          "There is no light signal from the local "
 188                          "fibre channel cable\n");
 189                 break;
 190         case FSF_PSQ_LINK_WRAP_PLUG:
 191                 dev_warn(&req->adapter->ccw_device->dev,
 192                          "There is a wrap plug instead of a fibre "
 193                          "channel cable\n");
 194                 break;
 195         case FSF_PSQ_LINK_NO_FCP:
 196                 dev_warn(&req->adapter->ccw_device->dev,
 197                          "The adjacent fibre channel node does not "
 198                          "support FCP\n");
 199                 break;
 200         case FSF_PSQ_LINK_FIRMWARE_UPDATE:
 201                 dev_warn(&req->adapter->ccw_device->dev,
 202                          "The FCP device is suspended because of a "
 203                          "firmware update\n");
 204                 break;
 205         case FSF_PSQ_LINK_INVALID_WWPN:
 206                 dev_warn(&req->adapter->ccw_device->dev,
 207                          "The FCP device detected a WWPN that is "
 208                          "duplicate or not valid\n");
 209                 break;
 210         case FSF_PSQ_LINK_NO_NPIV_SUPPORT:
 211                 dev_warn(&req->adapter->ccw_device->dev,
 212                          "The fibre channel fabric does not support NPIV\n");
 213                 break;
 214         case FSF_PSQ_LINK_NO_FCP_RESOURCES:
 215                 dev_warn(&req->adapter->ccw_device->dev,
 216                          "The FCP adapter cannot support more NPIV ports\n");
 217                 break;
 218         case FSF_PSQ_LINK_NO_FABRIC_RESOURCES:
 219                 dev_warn(&req->adapter->ccw_device->dev,
 220                          "The adjacent switch cannot support "
 221                          "more NPIV ports\n");
 222                 break;
 223         case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE:
 224                 dev_warn(&req->adapter->ccw_device->dev,
 225                          "The FCP adapter could not log in to the "
 226                          "fibre channel fabric\n");
 227                 break;
 228         case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED:
 229                 dev_warn(&req->adapter->ccw_device->dev,
 230                          "The WWPN assignment file on the FCP adapter "
 231                          "has been damaged\n");
 232                 break;
 233         case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED:
 234                 dev_warn(&req->adapter->ccw_device->dev,
 235                          "The mode table on the FCP adapter "
 236                          "has been damaged\n");
 237                 break;
 238         case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT:
 239                 dev_warn(&req->adapter->ccw_device->dev,
 240                          "All NPIV ports on the FCP adapter have "
 241                          "been assigned\n");
 242                 break;
 243         default:
 244                 dev_warn(&req->adapter->ccw_device->dev,
 245                          "The link between the FCP adapter and "
 246                          "the FC fabric is down\n");
 247         }
 248 out:
 249         zfcp_erp_adapter_failed(adapter, id, req);
 250 }
 251
 252 static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
 253 {
 254         struct fsf_status_read_buffer *sr_buf = req->data;
 255         struct fsf_link_down_info *ldi =
 256                 (struct fsf_link_down_info *) &sr_buf->payload;
 257
 258         switch (sr_buf->status_subtype) {
 259         case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
 260                 zfcp_fsf_link_down_info_eval(req, "fssrld1", ldi);
 261                 break;
 262         case FSF_STATUS_READ_SUB_FDISC_FAILED:
 263                 zfcp_fsf_link_down_info_eval(req, "fssrld2", ldi);
 264                 break;
 265         case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
 266                 zfcp_fsf_link_down_info_eval(req, "fssrld3", NULL);
 267         };
 268 }
 269
 270 static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
 271 {
 272         struct zfcp_adapter *adapter = req->adapter;
 273         struct fsf_status_read_buffer *sr_buf = req->data;
 274
 275         if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
 276                 zfcp_hba_dbf_event_fsf_unsol("dism", adapter, sr_buf);
 277                 mempool_free(sr_buf, adapter->pool.data_status_read);
 278                 zfcp_fsf_req_free(req);
 279                 return;
 280         }
 281
 282         zfcp_hba_dbf_event_fsf_unsol("read", adapter, sr_buf);
 283
 284         switch (sr_buf->status_type) {
 285         case FSF_STATUS_READ_PORT_CLOSED:
 286                 zfcp_fsf_status_read_port_closed(req);
 287                 break;
 288         case FSF_STATUS_READ_INCOMING_ELS:
 289                 zfcp_fc_incoming_els(req);
 290                 break;
 291         case FSF_STATUS_READ_SENSE_DATA_AVAIL:
 292                 break;
 293         case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
 294                 dev_warn(&adapter->ccw_device->dev,
 295                          "The error threshold for checksum statistics "
 296                          "has been exceeded\n");
 297                 zfcp_hba_dbf_event_berr(adapter, req);
 298                 break;
 299         case FSF_STATUS_READ_LINK_DOWN:
 300                 zfcp_fsf_status_read_link_down(req);
 301                 break;
 302         case FSF_STATUS_READ_LINK_UP:
 303                 dev_info(&adapter->ccw_device->dev,
 304                          "The local link has been restored\n");
 305                 /* All ports should be marked as ready to run again */
 306                 zfcp_erp_modify_adapter_status(adapter, "fssrh_1", NULL,
 307                                                ZFCP_STATUS_COMMON_RUNNING,
 308                                                ZFCP_SET);
 309                 zfcp_erp_adapter_reopen(adapter,
 310                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
 311                                         ZFCP_STATUS_COMMON_ERP_FAILED,
 312                                         "fssrh_2", req);
 313                 break;
 314         case FSF_STATUS_READ_NOTIFICATION_LOST:
 315                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_ACT_UPDATED)
 316                         zfcp_erp_adapter_access_changed(adapter, "fssrh_3",
 317                                                         req);
 318                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
 319                         schedule_work(&adapter->scan_work);
 320                 break;
 321         case FSF_STATUS_READ_CFDC_UPDATED:
 322                 zfcp_erp_adapter_access_changed(adapter, "fssrh_4", req);
 323                 break;
 324         case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
 325                 adapter->adapter_features = sr_buf->payload.word[0];
 326                 break;
 327         }
 328
 329         mempool_free(sr_buf, adapter->pool.data_status_read);
 330         zfcp_fsf_req_free(req);
 331
 332         atomic_inc(&adapter->stat_miss);
 333         queue_work(zfcp_data.work_queue, &adapter->stat_work);
 334 }
 335
 336 static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
 337 {
 338         switch (req->qtcb->header.fsf_status_qual.word[0]) {
 339         case FSF_SQ_FCP_RSP_AVAILABLE:
 340         case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
 341         case FSF_SQ_NO_RETRY_POSSIBLE:
 342         case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
 343                 return;
 344         case FSF_SQ_COMMAND_ABORTED:
 345                 req->status |= ZFCP_STATUS_FSFREQ_ABORTED;
 346                 break;
 347         case FSF_SQ_NO_RECOM:
 348                 dev_err(&req->adapter->ccw_device->dev,
 349                         "The FCP adapter reported a problem "
 350                         "that cannot be recovered\n");
 351                 zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1", req);
 352                 break;
 353         }
 354         /* all non-return stats set FSFREQ_ERROR*/
 355         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 356 }
 357
 358 static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
 359 {
 360         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
 361                 return;
 362
 363         switch (req->qtcb->header.fsf_status) {
 364         case FSF_UNKNOWN_COMMAND:
 365                 dev_err(&req->adapter->ccw_device->dev,
 366                         "The FCP adapter does not recognize the command 0x%x\n",
 367                         req->qtcb->header.fsf_command);
 368                 zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1", req);
 369                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 370                 break;
 371         case FSF_ADAPTER_STATUS_AVAILABLE:
 372                 zfcp_fsf_fsfstatus_qual_eval(req);
 373                 break;
 374         }
 375 }
 376
 377 static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
 378 {
 379         struct zfcp_adapter *adapter = req->adapter;
 380         struct fsf_qtcb *qtcb = req->qtcb;
 381         union fsf_prot_status_qual *psq = &qtcb->prefix.prot_status_qual;
 382
 383         zfcp_hba_dbf_event_fsf_response(req);
 384
 385         if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
 386                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
 387                         ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */
 388                 return;
 389         }
 390
 391         switch (qtcb->prefix.prot_status) {
 392         case FSF_PROT_GOOD:
 393         case FSF_PROT_FSF_STATUS_PRESENTED:
 394                 return;
 395         case FSF_PROT_QTCB_VERSION_ERROR:
 396                 dev_err(&adapter->ccw_device->dev,
 397                         "QTCB version 0x%x not supported by FCP adapter "
 398                         "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
 399                         psq->word[0], psq->word[1]);
 400                 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1", req);
 401                 break;
 402         case FSF_PROT_ERROR_STATE:
 403         case FSF_PROT_SEQ_NUMB_ERROR:
 404                 zfcp_erp_adapter_reopen(adapter, 0, "fspse_2", req);
 405                 req->status |= ZFCP_STATUS_FSFREQ_RETRY;
 406                 break;
 407         case FSF_PROT_UNSUPP_QTCB_TYPE:
 408                 dev_err(&adapter->ccw_device->dev,
 409                         "The QTCB type is not supported by the FCP adapter\n");
 410                 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3", req);
 411                 break;
 412         case FSF_PROT_HOST_CONNECTION_INITIALIZING:
 413                 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 414                                 &adapter->status);
 415                 break;
 416         case FSF_PROT_DUPLICATE_REQUEST_ID:
 417                 dev_err(&adapter->ccw_device->dev,
 418                         "0x%Lx is an ambiguous request identifier\n",
 419                         (unsigned long long)qtcb->bottom.support.req_handle);
 420                 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4", req);
 421                 break;
 422         case FSF_PROT_LINK_DOWN:
 423                 zfcp_fsf_link_down_info_eval(req, "fspse_5",
 424                                              &psq->link_down_info);
 425                 /* FIXME: reopening adapter now? better wait for link up */
 426                 zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req);
 427                 break;
 428         case FSF_PROT_REEST_QUEUE:
 429                 /* All ports should be marked as ready to run again */
 430                 zfcp_erp_modify_adapter_status(adapter, "fspse_7", NULL,
 431                                                ZFCP_STATUS_COMMON_RUNNING,
 432                                                ZFCP_SET);
 433                 zfcp_erp_adapter_reopen(adapter,
 434                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
 435                                         ZFCP_STATUS_COMMON_ERP_FAILED,
 436                                         "fspse_8", req);
 437                 break;
 438         default:
 439                 dev_err(&adapter->ccw_device->dev,
 440                         "0x%x is not a valid transfer protocol status\n",
 441                         qtcb->prefix.prot_status);
 442                 zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9", req);
 443         }
 444         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 445 }
 446
 447 /**
 448  * zfcp_fsf_req_complete - process completion of a FSF request
 449  * @fsf_req: The FSF request that has been completed.
 450  *
 451  * When a request has been completed either from the FCP adapter,
 452  * or it has been dismissed due to a queue shutdown, this function
 453  * is called to process the completion status and trigger further
 454  * events related to the FSF request.
 455  */
 456 void zfcp_fsf_req_complete(struct zfcp_fsf_req *req)
 457 {
 458         if (unlikely(req->fsf_command == FSF_QTCB_UNSOLICITED_STATUS)) {
 459                 zfcp_fsf_status_read_handler(req);
 460                 return;
 461         }
 462
 463         del_timer(&req->timer);
 464         zfcp_fsf_protstatus_eval(req);
 465         zfcp_fsf_fsfstatus_eval(req);
 466         req->handler(req);
 467
 468         if (req->erp_action)
 469                 zfcp_erp_notify(req->erp_action, 0);
 470         req->status |= ZFCP_STATUS_FSFREQ_COMPLETED;
 471
 472         if (likely(req->status & ZFCP_STATUS_FSFREQ_CLEANUP))
 473                 zfcp_fsf_req_free(req);
 474         else
 475         /* notify initiator waiting for the requests completion */
 476         /*
 477          * FIXME: Race! We must not access fsf_req here as it might have been
 478          * cleaned up already due to the set ZFCP_STATUS_FSFREQ_COMPLETED
 479          * flag. It's an improbable case. But, we have the same paranoia for
 480          * the cleanup flag already.
 481          * Might better be handled using complete()?
 482          * (setting the flag and doing wakeup ought to be atomic
 483          *  with regard to checking the flag as long as waitqueue is
 484          *  part of the to be released structure)
 485          */
 486                 wake_up(&req->completion_wq);
 487 }
 488
 489 static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
 490 {
 491         struct fsf_qtcb_bottom_config *bottom;
 492         struct zfcp_adapter *adapter = req->adapter;
 493         struct Scsi_Host *shost = adapter->scsi_host;
 494
 495         bottom = &req->qtcb->bottom.config;
 496
 497         if (req->data)
 498                 memcpy(req->data, bottom, sizeof(*bottom));
 499
 500         fc_host_node_name(shost) = bottom->nport_serv_param.wwnn;
 501         fc_host_port_name(shost) = bottom->nport_serv_param.wwpn;
 502         fc_host_port_id(shost) = bottom->s_id & ZFCP_DID_MASK;
 503         fc_host_speed(shost) = bottom->fc_link_speed;
 504         fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3;
 505
 506         adapter->hydra_version = bottom->adapter_type;
 507         adapter->timer_ticks = bottom->timer_interval;
 508
 509         if (fc_host_permanent_port_name(shost) == -1)
 510                 fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
 511
 512         switch (bottom->fc_topology) {
 513         case FSF_TOPO_P2P:
 514                 adapter->peer_d_id = bottom->peer_d_id & ZFCP_DID_MASK;
 515                 adapter->peer_wwpn = bottom->plogi_payload.wwpn;
 516                 adapter->peer_wwnn = bottom->plogi_payload.wwnn;
 517                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
 518                 break;
 519         case FSF_TOPO_FABRIC:
 520                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
 521                 break;
 522         case FSF_TOPO_AL:
 523                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
 524         default:
 525                 dev_err(&adapter->ccw_device->dev,
 526                         "Unknown or unsupported arbitrated loop "
 527                         "fibre channel topology detected\n");
 528                 zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1", req);
 529                 return -EIO;
 530         }
 531
 532         return 0;
 533 }
 534
 535 static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
 536 {
 537         struct zfcp_adapter *adapter = req->adapter;
 538         struct fsf_qtcb *qtcb = req->qtcb;
 539         struct fsf_qtcb_bottom_config *bottom = &qtcb->bottom.config;
 540         struct Scsi_Host *shost = adapter->scsi_host;
 541
 542         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
 543                 return;
 544
 545         adapter->fsf_lic_version = bottom->lic_version;
 546         adapter->adapter_features = bottom->adapter_features;
 547         adapter->connection_features = bottom->connection_features;
 548         adapter->peer_wwpn = 0;
 549         adapter->peer_wwnn = 0;
 550         adapter->peer_d_id = 0;
 551
 552         switch (qtcb->header.fsf_status) {
 553         case FSF_GOOD:
 554                 if (zfcp_fsf_exchange_config_evaluate(req))
 555                         return;
 556
 557                 if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
 558                         dev_err(&adapter->ccw_device->dev,
 559                                 "FCP adapter maximum QTCB size (%d bytes) "
 560                                 "is too small\n",
 561                                 bottom->max_qtcb_size);
 562                         zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1", req);
 563                         return;
 564                 }
 565                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
 566                                 &adapter->status);
 567                 break;
 568         case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
 569                 fc_host_node_name(shost) = 0;
 570                 fc_host_port_name(shost) = 0;
 571                 fc_host_port_id(shost) = 0;
 572                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
 573                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
 574                 adapter->hydra_version = 0;
 575
 576                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
 577                                 &adapter->status);
 578
 579                 zfcp_fsf_link_down_info_eval(req, "fsecdh2",
 580                         &qtcb->header.fsf_status_qual.link_down_info);
 581                 break;
 582         default:
 583                 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3", req);
 584                 return;
 585         }
 586
 587         if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
 588                 adapter->hardware_version = bottom->hardware_version;
 589                 memcpy(fc_host_serial_number(shost), bottom->serial_number,
 590                        min(FC_SERIAL_NUMBER_SIZE, 17));
 591                 EBCASC(fc_host_serial_number(shost),
 592                        min(FC_SERIAL_NUMBER_SIZE, 17));
 593         }
 594
 595         if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) {
 596                 dev_err(&adapter->ccw_device->dev,
 597                         "The FCP adapter only supports newer "
 598                         "control block versions\n");
 599                 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4", req);
 600                 return;
 601         }
 602         if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
 603                 dev_err(&adapter->ccw_device->dev,
 604                         "The FCP adapter only supports older "
 605                         "control block versions\n");
 606                 zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5", req);
 607         }
 608 }
 609
 610 static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req)
 611 {
 612         struct zfcp_adapter *adapter = req->adapter;
 613         struct fsf_qtcb_bottom_port *bottom = &req->qtcb->bottom.port;
 614         struct Scsi_Host *shost = adapter->scsi_host;
 615
 616         if (req->data)
 617                 memcpy(req->data, bottom, sizeof(*bottom));
 618
 619         if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
 620                 fc_host_permanent_port_name(shost) = bottom->wwpn;
 621         else
 622                 fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
 623         fc_host_maxframe_size(shost) = bottom->maximum_frame_size;
 624         fc_host_supported_speeds(shost) = bottom->supported_speed;
 625 }
 626
 627 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
 628 {
 629         struct fsf_qtcb *qtcb = req->qtcb;
 630
 631         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
 632                 return;
 633
 634         switch (qtcb->header.fsf_status) {
 635         case FSF_GOOD:
 636                 zfcp_fsf_exchange_port_evaluate(req);
 637                 break;
 638         case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
 639                 zfcp_fsf_exchange_port_evaluate(req);
 640                 zfcp_fsf_link_down_info_eval(req, "fsepdh1",
 641                         &qtcb->header.fsf_status_qual.link_down_info);
 642                 break;
 643         }
 644 }
 645
 646 static int zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter)
 647         __releases(&adapter->req_q_lock)
 648         __acquires(&adapter->req_q_lock)
 649 {
 650         struct zfcp_qdio_queue *req_q = &adapter->req_q;
 651         long ret;
 652
 653         if (atomic_read(&req_q->count) <= -REQUEST_LIST_SIZE)
 654                 return -EIO;
 655         if (atomic_read(&req_q->count) > 0)
 656                 return 0;
 657
 658         atomic_dec(&req_q->count);
 659         spin_unlock_bh(&adapter->req_q_lock);
 660         ret = wait_event_interruptible_timeout(adapter->request_wq,
 661                                         atomic_read(&req_q->count) >= 0,
 662                                         5 * HZ);
 663         spin_lock_bh(&adapter->req_q_lock);
 664         atomic_inc(&req_q->count);
 665
 666         if (ret > 0)
 667                 return 0;
 668         if (!ret)
 669                 atomic_inc(&adapter->qdio_outb_full);
 670         return -EIO;
 671 }
 672
 673 static struct zfcp_fsf_req *zfcp_fsf_alloc_noqtcb(mempool_t *pool)
 674 {
 675         struct zfcp_fsf_req *req;
 676         req = mempool_alloc(pool, GFP_ATOMIC);
 677         if (!req)
 678                 return NULL;
 679         memset(req, 0, sizeof(*req));
 680         req->pool = pool;
 681         return req;
 682 }
 683
 684 static struct zfcp_fsf_req *zfcp_fsf_alloc_qtcb(mempool_t *pool)
 685 {
 686         struct zfcp_fsf_req_qtcb *qtcb;
 687
 688         if (likely(pool))
 689                 qtcb = mempool_alloc(pool, GFP_ATOMIC);
 690         else
 691                 qtcb = kmem_cache_alloc(zfcp_data.fsf_req_qtcb_cache,
 692                                         GFP_ATOMIC);
 693         if (unlikely(!qtcb))
 694                 return NULL;
 695
 696         memset(qtcb, 0, sizeof(*qtcb));
 697         qtcb->fsf_req.qtcb = &qtcb->qtcb;
 698         qtcb->fsf_req.pool = pool;
 699
 700         return &qtcb->fsf_req;
 701 }
 702
 703 static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_adapter *adapter,
 704                                                 u32 fsf_cmd, int req_flags,
 705                                                 mempool_t *pool)
 706 {
 707         struct qdio_buffer_element *sbale;
 708
 709         struct zfcp_fsf_req *req;
 710         struct zfcp_qdio_queue *req_q = &adapter->req_q;
 711
 712         if (req_flags & ZFCP_REQ_NO_QTCB)
 713                 req = zfcp_fsf_alloc_noqtcb(pool);
 714         else
 715                 req = zfcp_fsf_alloc_qtcb(pool);
 716
 717         if (unlikely(!req))
 718                 return ERR_PTR(-EIO);
 719
 720         if (adapter->req_no == 0)
 721                 adapter->req_no++;
 722
 723         INIT_LIST_HEAD(&req->list);
 724         init_timer(&req->timer);
 725         init_waitqueue_head(&req->completion_wq);
 726
 727         req->adapter = adapter;
 728         req->fsf_command = fsf_cmd;
 729         req->req_id = adapter->req_no;
 730         req->sbal_number = 1;
 731         req->sbal_first = req_q->first;
 732         req->sbal_last = req_q->first;
 733         req->sbale_curr = 1;
 734
 735         sbale = zfcp_qdio_sbale_req(req);
 736         sbale[0].addr = (void *) req->req_id;
 737         sbale[0].flags |= SBAL_FLAGS0_COMMAND;
 738
 739         if (likely(req->qtcb)) {
 740                 req->qtcb->prefix.req_seq_no = req->adapter->fsf_req_seq_no;
 741                 req->qtcb->prefix.req_id = req->req_id;
 742                 req->qtcb->prefix.ulp_info = 26;
 743                 req->qtcb->prefix.qtcb_type = fsf_qtcb_type[req->fsf_command];
 744                 req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION;
 745                 req->qtcb->header.req_handle = req->req_id;
 746                 req->qtcb->header.fsf_command = req->fsf_command;
 747                 req->seq_no = adapter->fsf_req_seq_no;
 748                 req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
 749                 sbale[1].addr = (void *) req->qtcb;
 750                 sbale[1].length = sizeof(struct fsf_qtcb);
 751         }
 752
 753         if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)) {
 754                 zfcp_fsf_req_free(req);
 755                 return ERR_PTR(-EIO);
 756         }
 757
 758         if (likely(req_flags & ZFCP_REQ_AUTO_CLEANUP))
 759                 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
 760
 761         return req;
 762 }
 763
 764 static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
 765 {
 766         struct zfcp_adapter *adapter = req->adapter;
 767         unsigned long flags;
 768         int idx;
 769
 770         /* put allocated FSF request into hash table */
 771         spin_lock_irqsave(&adapter->req_list_lock, flags);
 772         idx = zfcp_reqlist_hash(req->req_id);
 773         list_add_tail(&req->list, &adapter->req_list[idx]);
 774         spin_unlock_irqrestore(&adapter->req_list_lock, flags);
 775
 776         req->qdio_outb_usage = atomic_read(&adapter->req_q.count);
 777         req->issued = get_clock();
 778         if (zfcp_qdio_send(req)) {
 779                 del_timer(&req->timer);
 780                 spin_lock_irqsave(&adapter->req_list_lock, flags);
 781                 /* lookup request again, list might have changed */
 782                 if (zfcp_reqlist_find_safe(adapter, req))
 783                         zfcp_reqlist_remove(adapter, req);
 784                 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
 785                 zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req);
 786                 return -EIO;
 787         }
 788
 789         /* Don't increase for unsolicited status */
 790         if (req->qtcb)
 791                 adapter->fsf_req_seq_no++;
 792         adapter->req_no++;
 793
 794         return 0;
 795 }
 796
 797 /**
 798  * zfcp_fsf_status_read - send status read request
 799  * @adapter: pointer to struct zfcp_adapter
 800  * @req_flags: request flags
 801  * Returns: 0 on success, ERROR otherwise
 802  */
 803 int zfcp_fsf_status_read(struct zfcp_adapter *adapter)
 804 {
 805         struct zfcp_fsf_req *req;
 806         struct fsf_status_read_buffer *sr_buf;
 807         struct qdio_buffer_element *sbale;
 808         int retval = -EIO;
 809
 810         spin_lock_bh(&adapter->req_q_lock);
 811         if (zfcp_fsf_req_sbal_get(adapter))
 812                 goto out;
 813
 814         req = zfcp_fsf_req_create(adapter, FSF_QTCB_UNSOLICITED_STATUS,
 815                                   ZFCP_REQ_NO_QTCB,
 816                                   adapter->pool.fsf_req_status_read);
 817         if (IS_ERR(req)) {
 818                 retval = PTR_ERR(req);
 819                 goto out;
 820         }
 821
 822         sbale = zfcp_qdio_sbale_req(req);
 823         sbale[0].flags |= SBAL_FLAGS0_TYPE_STATUS;
 824         sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY;
 825         req->sbale_curr = 2;
 826
 827         sr_buf = mempool_alloc(adapter->pool.data_status_read, GFP_ATOMIC);
 828         if (!sr_buf) {
 829                 retval = -ENOMEM;
 830                 goto failed_buf;
 831         }
 832         memset(sr_buf, 0, sizeof(*sr_buf));
 833         req->data = sr_buf;
 834         sbale = zfcp_qdio_sbale_curr(req);
 835         sbale->addr = (void *) sr_buf;
 836         sbale->length = sizeof(*sr_buf);
 837
 838         retval = zfcp_fsf_req_send(req);
 839         if (retval)
 840                 goto failed_req_send;
 841
 842         goto out;
 843
 844 failed_req_send:
 845         mempool_free(sr_buf, adapter->pool.data_status_read);
 846 failed_buf:
 847         zfcp_fsf_req_free(req);
 848         zfcp_hba_dbf_event_fsf_unsol("fail", adapter, NULL);
 849 out:
 850         spin_unlock_bh(&adapter->req_q_lock);
 851         return retval;
 852 }
 853
 854 static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
 855 {
 856         struct zfcp_unit *unit = req->data;
 857         union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual;
 858
 859         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
 860                 return;
 861
 862         switch (req->qtcb->header.fsf_status) {
 863         case FSF_PORT_HANDLE_NOT_VALID:
 864                 if (fsq->word[0] == fsq->word[1]) {
 865                         zfcp_erp_adapter_reopen(unit->port->adapter, 0,
 866                                                 "fsafch1", req);
 867                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 868                 }
 869                 break;
 870         case FSF_LUN_HANDLE_NOT_VALID:
 871                 if (fsq->word[0] == fsq->word[1]) {
 872                         zfcp_erp_port_reopen(unit->port, 0, "fsafch2", req);
 873                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 874                 }
 875                 break;
 876         case FSF_FCP_COMMAND_DOES_NOT_EXIST:
 877                 req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
 878                 break;
 879         case FSF_PORT_BOXED:
 880                 zfcp_erp_port_boxed(unit->port, "fsafch3", req);
 881                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
 882                                ZFCP_STATUS_FSFREQ_RETRY;
 883                 break;
 884         case FSF_LUN_BOXED:
 885                 zfcp_erp_unit_boxed(unit, "fsafch4", req);
 886                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
 887                                ZFCP_STATUS_FSFREQ_RETRY;
 888                 break;
 889         case FSF_ADAPTER_STATUS_AVAILABLE:
 890                 switch (fsq->word[0]) {
 891                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
 892                         zfcp_test_link(unit->port);
 893                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
 894                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 895                         break;
 896                 }
 897                 break;
 898         case FSF_GOOD:
 899                 req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED;
 900                 break;
 901         }
 902 }
 903
 904 /**
 905  * zfcp_fsf_abort_fcp_command - abort running SCSI command
 906  * @old_req_id: unsigned long
 907  * @unit: pointer to struct zfcp_unit
 908  * Returns: pointer to struct zfcp_fsf_req
 909  */
 910
 911 struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
 912                                                 struct zfcp_unit *unit)
 913 {
 914         struct qdio_buffer_element *sbale;
 915         struct zfcp_fsf_req *req = NULL;
 916         struct zfcp_adapter *adapter = unit->port->adapter;
 917
 918         spin_lock_bh(&adapter->req_q_lock);
 919         if (zfcp_fsf_req_sbal_get(adapter))
 920                 goto out;
 921         req = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND,
 922                                   0, adapter->pool.fsf_req_abort);
 923         if (IS_ERR(req)) {
 924                 req = NULL;
 925                 goto out;
 926         }
 927
 928         if (unlikely(!(atomic_read(&unit->status) &
 929                        ZFCP_STATUS_COMMON_UNBLOCKED)))
 930                 goto out_error_free;
 931
 932         sbale = zfcp_qdio_sbale_req(req);
 933         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
 934         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 935
 936         req->data = unit;
 937         req->handler = zfcp_fsf_abort_fcp_command_handler;
 938         req->qtcb->header.lun_handle = unit->handle;
 939         req->qtcb->header.port_handle = unit->port->handle;
 940         req->qtcb->bottom.support.req_handle = (u64) old_req_id;
 941
 942         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
 943         if (!zfcp_fsf_req_send(req))
 944                 goto out;
 945
 946 out_error_free:
 947         zfcp_fsf_req_free(req);
 948         req = NULL;
 949 out:
 950         spin_unlock_bh(&adapter->req_q_lock);
 951         return req;
 952 }
 953
 954 static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
 955 {
 956         struct zfcp_adapter *adapter = req->adapter;
 957         struct zfcp_send_ct *send_ct = req->data;
 958         struct fsf_qtcb_header *header = &req->qtcb->header;
 959
 960         send_ct->status = -EINVAL;
 961
 962         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
 963                 goto skip_fsfstatus;
 964
 965         switch (header->fsf_status) {
 966         case FSF_GOOD:
 967                 zfcp_san_dbf_event_ct_response(req);
 968                 send_ct->status = 0;
 969                 break;
 970         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
 971                 zfcp_fsf_class_not_supp(req);
 972                 break;
 973         case FSF_ADAPTER_STATUS_AVAILABLE:
 974                 switch (header->fsf_status_qual.word[0]){
 975                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
 976                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
 977                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 978                         break;
 979                 }
 980                 break;
 981         case FSF_ACCESS_DENIED:
 982                 break;
 983         case FSF_PORT_BOXED:
 984                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
 985                                ZFCP_STATUS_FSFREQ_RETRY;
 986                 break;
 987         case FSF_PORT_HANDLE_NOT_VALID:
 988                 zfcp_erp_adapter_reopen(adapter, 0, "fsscth1", req);
 989         case FSF_GENERIC_COMMAND_REJECTED:
 990         case FSF_PAYLOAD_SIZE_MISMATCH:
 991         case FSF_REQUEST_SIZE_TOO_LARGE:
 992         case FSF_RESPONSE_SIZE_TOO_LARGE:
 993         case FSF_SBAL_MISMATCH:
 994                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 995                 break;
 996         }
 997
 998 skip_fsfstatus:
 999         if (send_ct->handler)
1000                 send_ct->handler(send_ct->handler_data);
1001 }
1002
1003 static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
1004                                        struct scatterlist *sg_req,
1005                                        struct scatterlist *sg_resp,
1006                                        int max_sbals)
1007 {
1008         struct qdio_buffer_element *sbale = zfcp_qdio_sbale_req(req);
1009         u32 feat = req->adapter->adapter_features;
1010         int bytes;
1011
1012         if (!(feat & FSF_FEATURE_ELS_CT_CHAINED_SBALS)) {
1013                 if (sg_req->length > PAGE_SIZE || sg_resp->length > PAGE_SIZE ||
1014                     !sg_is_last(sg_req) || !sg_is_last(sg_resp))
1015                         return -EOPNOTSUPP;
1016
1017                 sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE_READ;
1018                 sbale[2].addr   = sg_virt(sg_req);
1019                 sbale[2].length = sg_req->length;
1020                 sbale[3].addr   = sg_virt(sg_resp);
1021                 sbale[3].length = sg_resp->length;
1022                 sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY;
1023                 return 0;
1024         }
1025
1026         bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ,
1027                                         sg_req, max_sbals);
1028         if (bytes <= 0)
1029                 return -ENOMEM;
1030         req->qtcb->bottom.support.req_buf_length = bytes;
1031         req->sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
1032
1033         bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ,
1034                                         sg_resp, max_sbals);
1035         if (bytes <= 0)
1036                 return -ENOMEM;
1037         req->qtcb->bottom.support.resp_buf_length = bytes;
1038
1039         return 0;
1040 }
1041
1042 /**
1043  * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
1044  * @ct: pointer to struct zfcp_send_ct with data for request
1045  * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
1046  * @erp_action: if non-null the Generic Service request sent within ERP
1047  */
1048 int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool,
1049                      struct zfcp_erp_action *erp_action)
1050 {
1051         struct zfcp_wka_port *wka_port = ct->wka_port;
1052         struct zfcp_adapter *adapter = wka_port->adapter;
1053         struct zfcp_fsf_req *req;
1054         int ret = -EIO;
1055
1056         spin_lock_bh(&adapter->req_q_lock);
1057         if (zfcp_fsf_req_sbal_get(adapter))
1058                 goto out;
1059
1060         req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_GENERIC,
1061                                   ZFCP_REQ_AUTO_CLEANUP, pool);
1062         if (IS_ERR(req)) {
1063                 ret = PTR_ERR(req);
1064                 goto out;
1065         }
1066
1067         ret = zfcp_fsf_setup_ct_els_sbals(req, ct->req, ct->resp,
1068                                           FSF_MAX_SBALS_PER_REQ);
1069         if (ret)
1070                 goto failed_send;
1071
1072         req->handler = zfcp_fsf_send_ct_handler;
1073         req->qtcb->header.port_handle = wka_port->handle;
1074         req->qtcb->bottom.support.service_class = FSF_CLASS_3;
1075         req->qtcb->bottom.support.timeout = ct->timeout;
1076         req->data = ct;
1077
1078         zfcp_san_dbf_event_ct_request(req);
1079
1080         if (erp_action) {
1081                 erp_action->fsf_req = req;
1082                 req->erp_action = erp_action;
1083                 zfcp_fsf_start_erp_timer(req);
1084         } else
1085                 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1086
1087         ret = zfcp_fsf_req_send(req);
1088         if (ret)
1089                 goto failed_send;
1090
1091         goto out;
1092
1093 failed_send:
1094         zfcp_fsf_req_free(req);
1095         if (erp_action)
1096                 erp_action->fsf_req = NULL;
1097 out:
1098         spin_unlock_bh(&adapter->req_q_lock);
1099         return ret;
1100 }
1101
1102 static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
1103 {
1104         struct zfcp_send_els *send_els = req->data;
1105         struct zfcp_port *port = send_els->port;
1106         struct fsf_qtcb_header *header = &req->qtcb->header;
1107
1108         send_els->status = -EINVAL;
1109
1110         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1111                 goto skip_fsfstatus;
1112
1113         switch (header->fsf_status) {
1114         case FSF_GOOD:
1115                 zfcp_san_dbf_event_els_response(req);
1116                 send_els->status = 0;
1117                 break;
1118         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
1119                 zfcp_fsf_class_not_supp(req);
1120                 break;
1121         case FSF_ADAPTER_STATUS_AVAILABLE:
1122                 switch (header->fsf_status_qual.word[0]){
1123                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1124                         if (port && (send_els->ls_code != ZFCP_LS_ADISC))
1125                                 zfcp_test_link(port);
1126                         /*fall through */
1127                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1128                 case FSF_SQ_RETRY_IF_POSSIBLE:
1129                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1130                         break;
1131                 }
1132                 break;
1133         case FSF_ELS_COMMAND_REJECTED:
1134         case FSF_PAYLOAD_SIZE_MISMATCH:
1135         case FSF_REQUEST_SIZE_TOO_LARGE:
1136         case FSF_RESPONSE_SIZE_TOO_LARGE:
1137                 break;
1138         case FSF_ACCESS_DENIED:
1139                 zfcp_fsf_access_denied_port(req, port);
1140                 break;
1141         case FSF_SBAL_MISMATCH:
1142                 /* should never occure, avoided in zfcp_fsf_send_els */
1143                 /* fall through */
1144         default:
1145                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1146                 break;
1147         }
1148 skip_fsfstatus:
1149         if (send_els->handler)
1150                 send_els->handler(send_els->handler_data);
1151 }
1152
1153 /**
1154  * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
1155  * @els: pointer to struct zfcp_send_els with data for the command
1156  */
1157 int zfcp_fsf_send_els(struct zfcp_send_els *els)
1158 {
1159         struct zfcp_fsf_req *req;
1160         struct zfcp_adapter *adapter = els->adapter;
1161         struct fsf_qtcb_bottom_support *bottom;
1162         int ret = -EIO;
1163
1164         if (unlikely(!(atomic_read(&els->port->status) &
1165                        ZFCP_STATUS_COMMON_UNBLOCKED)))
1166                 return -EBUSY;
1167
1168         spin_lock_bh(&adapter->req_q_lock);
1169         if (zfcp_fsf_req_sbal_get(adapter))
1170                 goto out;
1171         req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS,
1172                                   ZFCP_REQ_AUTO_CLEANUP, NULL);
1173         if (IS_ERR(req)) {
1174                 ret = PTR_ERR(req);
1175                 goto out;
1176         }
1177
1178         ret = zfcp_fsf_setup_ct_els_sbals(req, els->req, els->resp, 2);
1179
1180         if (ret)
1181                 goto failed_send;
1182
1183         bottom = &req->qtcb->bottom.support;
1184         req->handler = zfcp_fsf_send_els_handler;
1185         bottom->d_id = els->d_id;
1186         bottom->service_class = FSF_CLASS_3;
1187         bottom->timeout = 2 * R_A_TOV;
1188         req->data = els;
1189
1190         zfcp_san_dbf_event_els_request(req);
1191
1192         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1193         ret = zfcp_fsf_req_send(req);
1194         if (ret)
1195                 goto failed_send;
1196
1197         goto out;
1198
1199 failed_send:
1200         zfcp_fsf_req_free(req);
1201 out:
1202         spin_unlock_bh(&adapter->req_q_lock);
1203         return ret;
1204 }
1205
1206 int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
1207 {
1208         struct qdio_buffer_element *sbale;
1209         struct zfcp_fsf_req *req;
1210         struct zfcp_adapter *adapter = erp_action->adapter;
1211         int retval = -EIO;
1212
1213         spin_lock_bh(&adapter->req_q_lock);
1214         if (zfcp_fsf_req_sbal_get(adapter))
1215                 goto out;
1216         req = zfcp_fsf_req_create(adapter,
1217                                   FSF_QTCB_EXCHANGE_CONFIG_DATA,
1218                                   ZFCP_REQ_AUTO_CLEANUP,
1219                                   adapter->pool.fsf_req_erp);
1220         if (IS_ERR(req)) {
1221                 retval = PTR_ERR(req);
1222                 goto out;
1223         }
1224
1225         sbale = zfcp_qdio_sbale_req(req);
1226         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1227         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1228
1229         req->qtcb->bottom.config.feature_selection =
1230                         FSF_FEATURE_CFDC |
1231                         FSF_FEATURE_LUN_SHARING |
1232                         FSF_FEATURE_NOTIFICATION_LOST |
1233                         FSF_FEATURE_UPDATE_ALERT;
1234         req->erp_action = erp_action;
1235         req->handler = zfcp_fsf_exchange_config_data_handler;
1236         erp_action->fsf_req = req;
1237
1238         zfcp_fsf_start_erp_timer(req);
1239         retval = zfcp_fsf_req_send(req);
1240         if (retval) {
1241                 zfcp_fsf_req_free(req);
1242                 erp_action->fsf_req = NULL;
1243         }
1244 out:
1245         spin_unlock_bh(&adapter->req_q_lock);
1246         return retval;
1247 }
1248
1249 int zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter,
1250                                        struct fsf_qtcb_bottom_config *data)
1251 {
1252         struct qdio_buffer_element *sbale;
1253         struct zfcp_fsf_req *req = NULL;
1254         int retval = -EIO;
1255
1256         spin_lock_bh(&adapter->req_q_lock);
1257         if (zfcp_fsf_req_sbal_get(adapter))
1258                 goto out;
1259
1260         req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_CONFIG_DATA,
1261                                   0, NULL);
1262         if (IS_ERR(req)) {
1263                 retval = PTR_ERR(req);
1264                 goto out;
1265         }
1266
1267         sbale = zfcp_qdio_sbale_req(req);
1268         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1269         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1270         req->handler = zfcp_fsf_exchange_config_data_handler;
1271
1272         req->qtcb->bottom.config.feature_selection =
1273                         FSF_FEATURE_CFDC |
1274                         FSF_FEATURE_LUN_SHARING |
1275                         FSF_FEATURE_NOTIFICATION_LOST |
1276                         FSF_FEATURE_UPDATE_ALERT;
1277
1278         if (data)
1279                 req->data = data;
1280
1281         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1282         retval = zfcp_fsf_req_send(req);
1283 out:
1284         spin_unlock_bh(&adapter->req_q_lock);
1285         if (!retval)
1286                 wait_event(req->completion_wq,
1287                            req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
1288
1289         zfcp_fsf_req_free(req);
1290
1291         return retval;
1292 }
1293
1294 /**
1295  * zfcp_fsf_exchange_port_data - request information about local port
1296  * @erp_action: ERP action for the adapter for which port data is requested
1297  * Returns: 0 on success, error otherwise
1298  */
1299 int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
1300 {
1301         struct qdio_buffer_element *sbale;
1302         struct zfcp_fsf_req *req;
1303         struct zfcp_adapter *adapter = erp_action->adapter;
1304         int retval = -EIO;
1305
1306         if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1307                 return -EOPNOTSUPP;
1308
1309         spin_lock_bh(&adapter->req_q_lock);
1310         if (zfcp_fsf_req_sbal_get(adapter))
1311                 goto out;
1312         req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA,
1313                                   ZFCP_REQ_AUTO_CLEANUP,
1314                                   adapter->pool.fsf_req_erp);
1315         if (IS_ERR(req)) {
1316                 retval = PTR_ERR(req);
1317                 goto out;
1318         }
1319
1320         sbale = zfcp_qdio_sbale_req(req);
1321         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1322         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1323
1324         req->handler = zfcp_fsf_exchange_port_data_handler;
1325         req->erp_action = erp_action;
1326         erp_action->fsf_req = req;
1327
1328         zfcp_fsf_start_erp_timer(req);
1329         retval = zfcp_fsf_req_send(req);
1330         if (retval) {
1331                 zfcp_fsf_req_free(req);
1332                 erp_action->fsf_req = NULL;
1333         }
1334 out:
1335         spin_unlock_bh(&adapter->req_q_lock);
1336         return retval;
1337 }
1338
1339 /**
1340  * zfcp_fsf_exchange_port_data_sync - request information about local port
1341  * @adapter: pointer to struct zfcp_adapter
1342  * @data: pointer to struct fsf_qtcb_bottom_port
1343  * Returns: 0 on success, error otherwise
1344  */
1345 int zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter *adapter,
1346                                      struct fsf_qtcb_bottom_port *data)
1347 {
1348         struct qdio_buffer_element *sbale;
1349         struct zfcp_fsf_req *req = NULL;
1350         int retval = -EIO;
1351
1352         if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
1353                 return -EOPNOTSUPP;
1354
1355         spin_lock_bh(&adapter->req_q_lock);
1356         if (zfcp_fsf_req_sbal_get(adapter))
1357                 goto out;
1358
1359         req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA, 0,
1360                                   NULL);
1361         if (IS_ERR(req)) {
1362                 retval = PTR_ERR(req);
1363                 goto out;
1364         }
1365
1366         if (data)
1367                 req->data = data;
1368
1369         sbale = zfcp_qdio_sbale_req(req);
1370         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1371         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1372
1373         req->handler = zfcp_fsf_exchange_port_data_handler;
1374         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1375         retval = zfcp_fsf_req_send(req);
1376 out:
1377         spin_unlock_bh(&adapter->req_q_lock);
1378         if (!retval)
1379                 wait_event(req->completion_wq,
1380                            req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
1381         zfcp_fsf_req_free(req);
1382
1383         return retval;
1384 }
1385
1386 static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
1387 {
1388         struct zfcp_port *port = req->data;
1389         struct fsf_qtcb_header *header = &req->qtcb->header;
1390         struct fsf_plogi *plogi;
1391
1392         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1393                 return;
1394
1395         switch (header->fsf_status) {
1396         case FSF_PORT_ALREADY_OPEN:
1397                 break;
1398         case FSF_ACCESS_DENIED:
1399                 zfcp_fsf_access_denied_port(req, port);
1400                 break;
1401         case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
1402                 dev_warn(&req->adapter->ccw_device->dev,
1403                          "Not enough FCP adapter resources to open "
1404                          "remote port 0x%016Lx\n",
1405                          (unsigned long long)port->wwpn);
1406                 zfcp_erp_port_failed(port, "fsoph_1", req);
1407                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1408                 break;
1409         case FSF_ADAPTER_STATUS_AVAILABLE:
1410                 switch (header->fsf_status_qual.word[0]) {
1411                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1412                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1413                 case FSF_SQ_NO_RETRY_POSSIBLE:
1414                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1415                         break;
1416                 }
1417                 break;
1418         case FSF_GOOD:
1419                 port->handle = header->port_handle;
1420                 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN |
1421                                 ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1422                 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1423                                   ZFCP_STATUS_COMMON_ACCESS_BOXED,
1424                                   &port->status);
1425                 /* check whether D_ID has changed during open */
1426                 /*
1427                  * FIXME: This check is not airtight, as the FCP channel does
1428                  * not monitor closures of target port connections caused on
1429                  * the remote side. Thus, they might miss out on invalidating
1430                  * locally cached WWPNs (and other N_Port parameters) of gone
1431                  * target ports. So, our heroic attempt to make things safe
1432                  * could be undermined by 'open port' response data tagged with
1433                  * obsolete WWPNs. Another reason to monitor potential
1434                  * connection closures ourself at least (by interpreting
1435                  * incoming ELS' and unsolicited status). It just crosses my
1436                  * mind that one should be able to cross-check by means of
1437                  * another GID_PN straight after a port has been opened.
1438                  * Alternately, an ADISC/PDISC ELS should suffice, as well.
1439                  */
1440                 plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els;
1441                 if (req->qtcb->bottom.support.els1_length >=
1442                     FSF_PLOGI_MIN_LEN) {
1443                         if (plogi->serv_param.wwpn != port->wwpn)
1444                                 port->d_id = 0;
1445                         else {
1446                                 port->wwnn = plogi->serv_param.wwnn;
1447                                 zfcp_fc_plogi_evaluate(port, plogi);
1448                         }
1449                 }
1450                 break;
1451         case FSF_UNKNOWN_OP_SUBTYPE:
1452                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1453                 break;
1454         }
1455 }
1456
1457 /**
1458  * zfcp_fsf_open_port - create and send open port request
1459  * @erp_action: pointer to struct zfcp_erp_action
1460  * Returns: 0 on success, error otherwise
1461  */
1462 int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
1463 {
1464         struct qdio_buffer_element *sbale;
1465         struct zfcp_adapter *adapter = erp_action->adapter;
1466         struct zfcp_fsf_req *req;
1467         int retval = -EIO;
1468
1469         spin_lock_bh(&adapter->req_q_lock);
1470         if (zfcp_fsf_req_sbal_get(adapter))
1471                 goto out;
1472
1473         req = zfcp_fsf_req_create(adapter,
1474                                   FSF_QTCB_OPEN_PORT_WITH_DID,
1475                                   ZFCP_REQ_AUTO_CLEANUP,
1476                                   adapter->pool.fsf_req_erp);
1477         if (IS_ERR(req)) {
1478                 retval = PTR_ERR(req);
1479                 goto out;
1480         }
1481
1482         sbale = zfcp_qdio_sbale_req(req);
1483         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1484         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1485
1486         req->handler = zfcp_fsf_open_port_handler;
1487         req->qtcb->bottom.support.d_id = erp_action->port->d_id;
1488         req->data = erp_action->port;
1489         req->erp_action = erp_action;
1490         erp_action->fsf_req = req;
1491
1492         zfcp_fsf_start_erp_timer(req);
1493         retval = zfcp_fsf_req_send(req);
1494         if (retval) {
1495                 zfcp_fsf_req_free(req);
1496                 erp_action->fsf_req = NULL;
1497         }
1498 out:
1499         spin_unlock_bh(&adapter->req_q_lock);
1500         return retval;
1501 }
1502
1503 static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
1504 {
1505         struct zfcp_port *port = req->data;
1506
1507         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1508                 return;
1509
1510         switch (req->qtcb->header.fsf_status) {
1511         case FSF_PORT_HANDLE_NOT_VALID:
1512                 zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1", req);
1513                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1514                 break;
1515         case FSF_ADAPTER_STATUS_AVAILABLE:
1516                 break;
1517         case FSF_GOOD:
1518                 zfcp_erp_modify_port_status(port, "fscph_2", req,
1519                                             ZFCP_STATUS_COMMON_OPEN,
1520                                             ZFCP_CLEAR);
1521                 break;
1522         }
1523 }
1524
1525 /**
1526  * zfcp_fsf_close_port - create and send close port request
1527  * @erp_action: pointer to struct zfcp_erp_action
1528  * Returns: 0 on success, error otherwise
1529  */
1530 int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
1531 {
1532         struct qdio_buffer_element *sbale;
1533         struct zfcp_adapter *adapter = erp_action->adapter;
1534         struct zfcp_fsf_req *req;
1535         int retval = -EIO;
1536
1537         spin_lock_bh(&adapter->req_q_lock);
1538         if (zfcp_fsf_req_sbal_get(adapter))
1539                 goto out;
1540
1541         req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT,
1542                                   ZFCP_REQ_AUTO_CLEANUP,
1543                                   adapter->pool.fsf_req_erp);
1544         if (IS_ERR(req)) {
1545                 retval = PTR_ERR(req);
1546                 goto out;
1547         }
1548
1549         sbale = zfcp_qdio_sbale_req(req);
1550         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1551         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1552
1553         req->handler = zfcp_fsf_close_port_handler;
1554         req->data = erp_action->port;
1555         req->erp_action = erp_action;
1556         req->qtcb->header.port_handle = erp_action->port->handle;
1557         erp_action->fsf_req = req;
1558
1559         zfcp_fsf_start_erp_timer(req);
1560         retval = zfcp_fsf_req_send(req);
1561         if (retval) {
1562                 zfcp_fsf_req_free(req);
1563                 erp_action->fsf_req = NULL;
1564         }
1565 out:
1566         spin_unlock_bh(&adapter->req_q_lock);
1567         return retval;
1568 }
1569
1570 static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
1571 {
1572         struct zfcp_wka_port *wka_port = req->data;
1573         struct fsf_qtcb_header *header = &req->qtcb->header;
1574
1575         if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
1576                 wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1577                 goto out;
1578         }
1579
1580         switch (header->fsf_status) {
1581         case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
1582                 dev_warn(&req->adapter->ccw_device->dev,
1583                          "Opening WKA port 0x%x failed\n", wka_port->d_id);
1584         case FSF_ADAPTER_STATUS_AVAILABLE:
1585                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1586         case FSF_ACCESS_DENIED:
1587                 wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1588                 break;
1589         case FSF_PORT_ALREADY_OPEN:
1590                 break;
1591         case FSF_GOOD:
1592                 wka_port->handle = header->port_handle;
1593                 wka_port->status = ZFCP_WKA_PORT_ONLINE;
1594         }
1595 out:
1596         wake_up(&wka_port->completion_wq);
1597 }
1598
1599 /**
1600  * zfcp_fsf_open_wka_port - create and send open wka-port request
1601  * @wka_port: pointer to struct zfcp_wka_port
1602  * Returns: 0 on success, error otherwise
1603  */
1604 int zfcp_fsf_open_wka_port(struct zfcp_wka_port *wka_port)
1605 {
1606         struct qdio_buffer_element *sbale;
1607         struct zfcp_adapter *adapter = wka_port->adapter;
1608         struct zfcp_fsf_req *req;
1609         int retval = -EIO;
1610
1611         spin_lock_bh(&adapter->req_q_lock);
1612         if (zfcp_fsf_req_sbal_get(adapter))
1613                 goto out;
1614
1615         req = zfcp_fsf_req_create(adapter,
1616                                   FSF_QTCB_OPEN_PORT_WITH_DID,
1617                                   ZFCP_REQ_AUTO_CLEANUP,
1618                                   adapter->pool.fsf_req_erp);
1619         if (unlikely(IS_ERR(req))) {
1620                 retval = PTR_ERR(req);
1621                 goto out;
1622         }
1623
1624         sbale = zfcp_qdio_sbale_req(req);
1625         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1626         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1627
1628         req->handler = zfcp_fsf_open_wka_port_handler;
1629         req->qtcb->bottom.support.d_id = wka_port->d_id;
1630         req->data = wka_port;
1631
1632         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1633         retval = zfcp_fsf_req_send(req);
1634         if (retval)
1635                 zfcp_fsf_req_free(req);
1636 out:
1637         spin_unlock_bh(&adapter->req_q_lock);
1638         return retval;
1639 }
1640
1641 static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
1642 {
1643         struct zfcp_wka_port *wka_port = req->data;
1644
1645         if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
1646                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1647                 zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1", req);
1648         }
1649
1650         wka_port->status = ZFCP_WKA_PORT_OFFLINE;
1651         wake_up(&wka_port->completion_wq);
1652 }
1653
1654 /**
1655  * zfcp_fsf_close_wka_port - create and send close wka port request
1656  * @erp_action: pointer to struct zfcp_erp_action
1657  * Returns: 0 on success, error otherwise
1658  */
1659 int zfcp_fsf_close_wka_port(struct zfcp_wka_port *wka_port)
1660 {
1661         struct qdio_buffer_element *sbale;
1662         struct zfcp_adapter *adapter = wka_port->adapter;
1663         struct zfcp_fsf_req *req;
1664         int retval = -EIO;
1665
1666         spin_lock_bh(&adapter->req_q_lock);
1667         if (zfcp_fsf_req_sbal_get(adapter))
1668                 goto out;
1669
1670         req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT,
1671                                   ZFCP_REQ_AUTO_CLEANUP,
1672                                   adapter->pool.fsf_req_erp);
1673         if (unlikely(IS_ERR(req))) {
1674                 retval = PTR_ERR(req);
1675                 goto out;
1676         }
1677
1678         sbale = zfcp_qdio_sbale_req(req);
1679         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1680         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1681
1682         req->handler = zfcp_fsf_close_wka_port_handler;
1683         req->data = wka_port;
1684         req->qtcb->header.port_handle = wka_port->handle;
1685
1686         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
1687         retval = zfcp_fsf_req_send(req);
1688         if (retval)
1689                 zfcp_fsf_req_free(req);
1690 out:
1691         spin_unlock_bh(&adapter->req_q_lock);
1692         return retval;
1693 }
1694
1695 static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
1696 {
1697         struct zfcp_port *port = req->data;
1698         struct fsf_qtcb_header *header = &req->qtcb->header;
1699         struct zfcp_unit *unit;
1700
1701         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1702                 return;
1703
1704         switch (header->fsf_status) {
1705         case FSF_PORT_HANDLE_NOT_VALID:
1706                 zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1", req);
1707                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1708                 break;
1709         case FSF_ACCESS_DENIED:
1710                 zfcp_fsf_access_denied_port(req, port);
1711                 break;
1712         case FSF_PORT_BOXED:
1713                 zfcp_erp_port_boxed(port, "fscpph2", req);
1714                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1715                                ZFCP_STATUS_FSFREQ_RETRY;
1716                 /* can't use generic zfcp_erp_modify_port_status because
1717                  * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
1718                 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1719                 list_for_each_entry(unit, &port->unit_list_head, list)
1720                         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1721                                           &unit->status);
1722                 break;
1723         case FSF_ADAPTER_STATUS_AVAILABLE:
1724                 switch (header->fsf_status_qual.word[0]) {
1725                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1726                         /* fall through */
1727                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1728                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1729                         break;
1730                 }
1731                 break;
1732         case FSF_GOOD:
1733                 /* can't use generic zfcp_erp_modify_port_status because
1734                  * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
1735                  */
1736                 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
1737                 list_for_each_entry(unit, &port->unit_list_head, list)
1738                         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1739                                           &unit->status);
1740                 break;
1741         }
1742 }
1743
1744 /**
1745  * zfcp_fsf_close_physical_port - close physical port
1746  * @erp_action: pointer to struct zfcp_erp_action
1747  * Returns: 0 on success
1748  */
1749 int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
1750 {
1751         struct qdio_buffer_element *sbale;
1752         struct zfcp_adapter *adapter = erp_action->adapter;
1753         struct zfcp_fsf_req *req;
1754         int retval = -EIO;
1755
1756         spin_lock_bh(&adapter->req_q_lock);
1757         if (zfcp_fsf_req_sbal_get(adapter))
1758                 goto out;
1759
1760         req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PHYSICAL_PORT,
1761                                   ZFCP_REQ_AUTO_CLEANUP,
1762                                   adapter->pool.fsf_req_erp);
1763         if (IS_ERR(req)) {
1764                 retval = PTR_ERR(req);
1765                 goto out;
1766         }
1767
1768         sbale = zfcp_qdio_sbale_req(req);
1769         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1770         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1771
1772         req->data = erp_action->port;
1773         req->qtcb->header.port_handle = erp_action->port->handle;
1774         req->erp_action = erp_action;
1775         req->handler = zfcp_fsf_close_physical_port_handler;
1776         erp_action->fsf_req = req;
1777
1778         zfcp_fsf_start_erp_timer(req);
1779         retval = zfcp_fsf_req_send(req);
1780         if (retval) {
1781                 zfcp_fsf_req_free(req);
1782                 erp_action->fsf_req = NULL;
1783         }
1784 out:
1785         spin_unlock_bh(&adapter->req_q_lock);
1786         return retval;
1787 }
1788
1789 static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
1790 {
1791         struct zfcp_adapter *adapter = req->adapter;
1792         struct zfcp_unit *unit = req->data;
1793         struct fsf_qtcb_header *header = &req->qtcb->header;
1794         struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
1795         struct fsf_queue_designator *queue_designator =
1796                                 &header->fsf_status_qual.fsf_queue_designator;
1797         int exclusive, readwrite;
1798
1799         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1800                 return;
1801
1802         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
1803                           ZFCP_STATUS_COMMON_ACCESS_BOXED |
1804                           ZFCP_STATUS_UNIT_SHARED |
1805                           ZFCP_STATUS_UNIT_READONLY,
1806                           &unit->status);
1807
1808         switch (header->fsf_status) {
1809
1810         case FSF_PORT_HANDLE_NOT_VALID:
1811                 zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fsouh_1", req);
1812                 /* fall through */
1813         case FSF_LUN_ALREADY_OPEN:
1814                 break;
1815         case FSF_ACCESS_DENIED:
1816                 zfcp_fsf_access_denied_unit(req, unit);
1817                 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
1818                 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
1819                 break;
1820         case FSF_PORT_BOXED:
1821                 zfcp_erp_port_boxed(unit->port, "fsouh_2", req);
1822                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1823                                ZFCP_STATUS_FSFREQ_RETRY;
1824                 break;
1825         case FSF_LUN_SHARING_VIOLATION:
1826                 if (header->fsf_status_qual.word[0])
1827                         dev_warn(&adapter->ccw_device->dev,
1828                                  "LUN 0x%Lx on port 0x%Lx is already in "
1829                                  "use by CSS%d, MIF Image ID %x\n",
1830                                  (unsigned long long)unit->fcp_lun,
1831                                  (unsigned long long)unit->port->wwpn,
1832                                  queue_designator->cssid,
1833                                  queue_designator->hla);
1834                 else
1835                         zfcp_act_eval_err(adapter,
1836                                           header->fsf_status_qual.word[2]);
1837                 zfcp_erp_unit_access_denied(unit, "fsouh_3", req);
1838                 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
1839                 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
1840                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1841                 break;
1842         case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
1843                 dev_warn(&adapter->ccw_device->dev,
1844                          "No handle is available for LUN "
1845                          "0x%016Lx on port 0x%016Lx\n",
1846                          (unsigned long long)unit->fcp_lun,
1847                          (unsigned long long)unit->port->wwpn);
1848                 zfcp_erp_unit_failed(unit, "fsouh_4", req);
1849                 /* fall through */
1850         case FSF_INVALID_COMMAND_OPTION:
1851                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1852                 break;
1853         case FSF_ADAPTER_STATUS_AVAILABLE:
1854                 switch (header->fsf_status_qual.word[0]) {
1855                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1856                         zfcp_test_link(unit->port);
1857                         /* fall through */
1858                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1859                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1860                         break;
1861                 }
1862                 break;
1863
1864         case FSF_GOOD:
1865                 unit->handle = header->lun_handle;
1866                 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
1867
1868                 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE) &&
1869                     (adapter->adapter_features & FSF_FEATURE_LUN_SHARING) &&
1870                     (adapter->ccw_device->id.dev_model != ZFCP_DEVICE_MODEL_PRIV)) {
1871                         exclusive = (bottom->lun_access_info &
1872                                         FSF_UNIT_ACCESS_EXCLUSIVE);
1873                         readwrite = (bottom->lun_access_info &
1874                                         FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);
1875
1876                         if (!exclusive)
1877                                 atomic_set_mask(ZFCP_STATUS_UNIT_SHARED,
1878                                                 &unit->status);
1879
1880                         if (!readwrite) {
1881                                 atomic_set_mask(ZFCP_STATUS_UNIT_READONLY,
1882                                                 &unit->status);
1883                                 dev_info(&adapter->ccw_device->dev,
1884                                          "SCSI device at LUN 0x%016Lx on port "
1885                                          "0x%016Lx opened read-only\n",
1886                                          (unsigned long long)unit->fcp_lun,
1887                                          (unsigned long long)unit->port->wwpn);
1888                         }
1889
1890                         if (exclusive && !readwrite) {
1891                                 dev_err(&adapter->ccw_device->dev,
1892                                         "Exclusive read-only access not "
1893                                         "supported (unit 0x%016Lx, "
1894                                         "port 0x%016Lx)\n",
1895                                         (unsigned long long)unit->fcp_lun,
1896                                         (unsigned long long)unit->port->wwpn);
1897                                 zfcp_erp_unit_failed(unit, "fsouh_5", req);
1898                                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1899                                 zfcp_erp_unit_shutdown(unit, 0, "fsouh_6", req);
1900                         } else if (!exclusive && readwrite) {
1901                                 dev_err(&adapter->ccw_device->dev,
1902                                         "Shared read-write access not "
1903                                         "supported (unit 0x%016Lx, port "
1904                                         "0x%016Lx)\n",
1905                                         (unsigned long long)unit->fcp_lun,
1906                                         (unsigned long long)unit->port->wwpn);
1907                                 zfcp_erp_unit_failed(unit, "fsouh_7", req);
1908                                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1909                                 zfcp_erp_unit_shutdown(unit, 0, "fsouh_8", req);
1910                         }
1911                 }
1912                 break;
1913         }
1914 }
1915
1916 /**
1917  * zfcp_fsf_open_unit - open unit
1918  * @erp_action: pointer to struct zfcp_erp_action
1919  * Returns: 0 on success, error otherwise
1920  */
1921 int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
1922 {
1923         struct qdio_buffer_element *sbale;
1924         struct zfcp_adapter *adapter = erp_action->adapter;
1925         struct zfcp_fsf_req *req;
1926         int retval = -EIO;
1927
1928         spin_lock_bh(&adapter->req_q_lock);
1929         if (zfcp_fsf_req_sbal_get(adapter))
1930                 goto out;
1931
1932         req = zfcp_fsf_req_create(adapter, FSF_QTCB_OPEN_LUN,
1933                                   ZFCP_REQ_AUTO_CLEANUP,
1934                                   adapter->pool.fsf_req_erp);
1935         if (IS_ERR(req)) {
1936                 retval = PTR_ERR(req);
1937                 goto out;
1938         }
1939
1940         sbale = zfcp_qdio_sbale_req(req);
1941         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
1942         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
1943
1944         req->qtcb->header.port_handle = erp_action->port->handle;
1945         req->qtcb->bottom.support.fcp_lun = erp_action->unit->fcp_lun;
1946         req->handler = zfcp_fsf_open_unit_handler;
1947         req->data = erp_action->unit;
1948         req->erp_action = erp_action;
1949         erp_action->fsf_req = req;
1950
1951         if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
1952                 req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
1953
1954         zfcp_fsf_start_erp_timer(req);
1955         retval = zfcp_fsf_req_send(req);
1956         if (retval) {
1957                 zfcp_fsf_req_free(req);
1958                 erp_action->fsf_req = NULL;
1959         }
1960 out:
1961         spin_unlock_bh(&adapter->req_q_lock);
1962         return retval;
1963 }
1964
1965 static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
1966 {
1967         struct zfcp_unit *unit = req->data;
1968
1969         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
1970                 return;
1971
1972         switch (req->qtcb->header.fsf_status) {
1973         case FSF_PORT_HANDLE_NOT_VALID:
1974                 zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fscuh_1", req);
1975                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1976                 break;
1977         case FSF_LUN_HANDLE_NOT_VALID:
1978                 zfcp_erp_port_reopen(unit->port, 0, "fscuh_2", req);
1979                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1980                 break;
1981         case FSF_PORT_BOXED:
1982                 zfcp_erp_port_boxed(unit->port, "fscuh_3", req);
1983                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
1984                                ZFCP_STATUS_FSFREQ_RETRY;
1985                 break;
1986         case FSF_ADAPTER_STATUS_AVAILABLE:
1987                 switch (req->qtcb->header.fsf_status_qual.word[0]) {
1988                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
1989                         zfcp_test_link(unit->port);
1990                         /* fall through */
1991                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
1992                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
1993                         break;
1994                 }
1995                 break;
1996         case FSF_GOOD:
1997                 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
1998                 break;
1999         }
2000 }
2001
2002 /**
2003  * zfcp_fsf_close_unit - close zfcp unit
2004  * @erp_action: pointer to struct zfcp_unit
2005  * Returns: 0 on success, error otherwise
2006  */
2007 int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
2008 {
2009         struct qdio_buffer_element *sbale;
2010         struct zfcp_adapter *adapter = erp_action->adapter;
2011         struct zfcp_fsf_req *req;
2012         int retval = -EIO;
2013
2014         spin_lock_bh(&adapter->req_q_lock);
2015         if (zfcp_fsf_req_sbal_get(adapter))
2016                 goto out;
2017         req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_LUN,
2018                                   ZFCP_REQ_AUTO_CLEANUP,
2019                                   adapter->pool.fsf_req_erp);
2020         if (IS_ERR(req)) {
2021                 retval = PTR_ERR(req);
2022                 goto out;
2023         }
2024
2025         sbale = zfcp_qdio_sbale_req(req);
2026         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
2027         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
2028
2029         req->qtcb->header.port_handle = erp_action->port->handle;
2030         req->qtcb->header.lun_handle = erp_action->unit->handle;
2031         req->handler = zfcp_fsf_close_unit_handler;
2032         req->data = erp_action->unit;
2033         req->erp_action = erp_action;
2034         erp_action->fsf_req = req;
2035
2036         zfcp_fsf_start_erp_timer(req);
2037         retval = zfcp_fsf_req_send(req);
2038         if (retval) {
2039                 zfcp_fsf_req_free(req);
2040                 erp_action->fsf_req = NULL;
2041         }
2042 out:
2043         spin_unlock_bh(&adapter->req_q_lock);
2044         return retval;
2045 }
2046
2047 static void zfcp_fsf_update_lat(struct fsf_latency_record *lat_rec, u32 lat)
2048 {
2049         lat_rec->sum += lat;
2050         lat_rec->min = min(lat_rec->min, lat);
2051         lat_rec->max = max(lat_rec->max, lat);
2052 }
2053
2054 static void zfcp_fsf_req_latency(struct zfcp_fsf_req *req)
2055 {
2056         struct fsf_qual_latency_info *lat_inf;
2057         struct latency_cont *lat;
2058         struct zfcp_unit *unit = req->unit;
2059
2060         lat_inf = &req->qtcb->prefix.prot_status_qual.latency_info;
2061
2062         switch (req->qtcb->bottom.io.data_direction) {
2063         case FSF_DATADIR_READ:
2064                 lat = &unit->latencies.read;
2065                 break;
2066         case FSF_DATADIR_WRITE:
2067                 lat = &unit->latencies.write;
2068                 break;
2069         case FSF_DATADIR_CMND:
2070                 lat = &unit->latencies.cmd;
2071                 break;
2072         default:
2073                 return;
2074         }
2075
2076         spin_lock(&unit->latencies.lock);
2077         zfcp_fsf_update_lat(&lat->channel, lat_inf->channel_lat);
2078         zfcp_fsf_update_lat(&lat->fabric, lat_inf->fabric_lat);
2079         lat->counter++;
2080         spin_unlock(&unit->latencies.lock);
2081 }
2082
2083 #ifdef CONFIG_BLK_DEV_IO_TRACE
2084 static void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
2085 {
2086         struct fsf_qual_latency_info *lat_inf;
2087         struct scsi_cmnd *scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
2088         struct request *req = scsi_cmnd->request;
2089         struct zfcp_blk_drv_data trace;
2090         int ticks = fsf_req->adapter->timer_ticks;
2091
2092         trace.flags = 0;
2093         trace.magic = ZFCP_BLK_DRV_DATA_MAGIC;
2094         if (fsf_req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) {
2095                 trace.flags |= ZFCP_BLK_LAT_VALID;
2096                 lat_inf = &fsf_req->qtcb->prefix.prot_status_qual.latency_info;
2097                 trace.channel_lat = lat_inf->channel_lat * ticks;
2098                 trace.fabric_lat = lat_inf->fabric_lat * ticks;
2099         }
2100         if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
2101                 trace.flags |= ZFCP_BLK_REQ_ERROR;
2102         trace.inb_usage = fsf_req->qdio_inb_usage;
2103         trace.outb_usage = fsf_req->qdio_outb_usage;
2104
2105         blk_add_driver_data(req->q, req, &trace, sizeof(trace));
2106 }
2107 #else
2108 static inline void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
2109 {
2110 }
2111 #endif
2112
2113 static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
2114 {
2115         struct scsi_cmnd *scpnt;
2116         struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
2117             &(req->qtcb->bottom.io.fcp_rsp);
2118         u32 sns_len;
2119         char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
2120         unsigned long flags;
2121
2122         read_lock_irqsave(&req->adapter->abort_lock, flags);
2123
2124         scpnt = req->data;
2125         if (unlikely(!scpnt)) {
2126                 read_unlock_irqrestore(&req->adapter->abort_lock, flags);
2127                 return;
2128         }
2129
2130         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ABORTED)) {
2131                 set_host_byte(scpnt, DID_SOFT_ERROR);
2132                 goto skip_fsfstatus;
2133         }
2134
2135         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
2136                 set_host_byte(scpnt, DID_ERROR);
2137                 goto skip_fsfstatus;
2138         }
2139
2140         set_msg_byte(scpnt, COMMAND_COMPLETE);
2141
2142         scpnt->result |= fcp_rsp_iu->scsi_status;
2143
2144         if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)
2145                 zfcp_fsf_req_latency(req);
2146
2147         zfcp_fsf_trace_latency(req);
2148
2149         if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) {
2150                 if (fcp_rsp_info[3] == RSP_CODE_GOOD)
2151                         set_host_byte(scpnt, DID_OK);
2152                 else {
2153                         set_host_byte(scpnt, DID_ERROR);
2154                         goto skip_fsfstatus;
2155                 }
2156         }
2157
2158         if (unlikely(fcp_rsp_iu->validity.bits.fcp_sns_len_valid)) {
2159                 sns_len = FSF_FCP_RSP_SIZE - sizeof(struct fcp_rsp_iu) +
2160                           fcp_rsp_iu->fcp_rsp_len;
2161                 sns_len = min(sns_len, (u32) SCSI_SENSE_BUFFERSIZE);
2162                 sns_len = min(sns_len, fcp_rsp_iu->fcp_sns_len);
2163
2164                 memcpy(scpnt->sense_buffer,
2165                        zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu), sns_len);
2166         }
2167
2168         if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_under)) {
2169                 scsi_set_resid(scpnt, fcp_rsp_iu->fcp_resid);
2170                 if (scsi_bufflen(scpnt) - scsi_get_resid(scpnt) <
2171                     scpnt->underflow)
2172                         set_host_byte(scpnt, DID_ERROR);
2173         }
2174 skip_fsfstatus:
2175         if (scpnt->result != 0)
2176                 zfcp_scsi_dbf_event_result("erro", 3, req->adapter, scpnt, req);
2177         else if (scpnt->retries > 0)
2178                 zfcp_scsi_dbf_event_result("retr", 4, req->adapter, scpnt, req);
2179         else
2180                 zfcp_scsi_dbf_event_result("norm", 6, req->adapter, scpnt, req);
2181
2182         scpnt->host_scribble = NULL;
2183         (scpnt->scsi_done) (scpnt);
2184         /*
2185          * We must hold this lock until scsi_done has been called.
2186          * Otherwise we may call scsi_done after abort regarding this
2187          * command has completed.
2188          * Note: scsi_done must not block!
2189          */
2190         read_unlock_irqrestore(&req->adapter->abort_lock, flags);
2191 }
2192
2193 static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req)
2194 {
2195         struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
2196             &(req->qtcb->bottom.io.fcp_rsp);
2197         char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
2198
2199         if ((fcp_rsp_info[3] != RSP_CODE_GOOD) ||
2200              (req->status & ZFCP_STATUS_FSFREQ_ERROR))
2201                 req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
2202 }
2203
2204
2205 static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
2206 {
2207         struct zfcp_unit *unit;
2208         struct fsf_qtcb_header *header = &req->qtcb->header;
2209
2210         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT))
2211                 unit = req->data;
2212         else
2213                 unit = req->unit;
2214
2215         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
2216                 goto skip_fsfstatus;
2217
2218         switch (header->fsf_status) {
2219         case FSF_HANDLE_MISMATCH:
2220         case FSF_PORT_HANDLE_NOT_VALID:
2221                 zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fssfch1", req);
2222                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2223                 break;
2224         case FSF_FCPLUN_NOT_VALID:
2225         case FSF_LUN_HANDLE_NOT_VALID:
2226                 zfcp_erp_port_reopen(unit->port, 0, "fssfch2", req);
2227                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2228                 break;
2229         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
2230                 zfcp_fsf_class_not_supp(req);
2231                 break;
2232         case FSF_ACCESS_DENIED:
2233                 zfcp_fsf_access_denied_unit(req, unit);
2234                 break;
2235         case FSF_DIRECTION_INDICATOR_NOT_VALID:
2236                 dev_err(&req->adapter->ccw_device->dev,
2237                         "Incorrect direction %d, unit 0x%016Lx on port "
2238                         "0x%016Lx closed\n",
2239                         req->qtcb->bottom.io.data_direction,
2240                         (unsigned long long)unit->fcp_lun,
2241                         (unsigned long long)unit->port->wwpn);
2242                 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, "fssfch3",
2243                                           req);
2244                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2245                 break;
2246         case FSF_CMND_LENGTH_NOT_VALID:
2247                 dev_err(&req->adapter->ccw_device->dev,
2248                         "Incorrect CDB length %d, unit 0x%016Lx on "
2249                         "port 0x%016Lx closed\n",
2250                         req->qtcb->bottom.io.fcp_cmnd_length,
2251                         (unsigned long long)unit->fcp_lun,
2252                         (unsigned long long)unit->port->wwpn);
2253                 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, "fssfch4",
2254                                           req);
2255                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2256                 break;
2257         case FSF_PORT_BOXED:
2258                 zfcp_erp_port_boxed(unit->port, "fssfch5", req);
2259                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
2260                                ZFCP_STATUS_FSFREQ_RETRY;
2261                 break;
2262         case FSF_LUN_BOXED:
2263                 zfcp_erp_unit_boxed(unit, "fssfch6", req);
2264                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
2265                                ZFCP_STATUS_FSFREQ_RETRY;
2266                 break;
2267         case FSF_ADAPTER_STATUS_AVAILABLE:
2268                 if (header->fsf_status_qual.word[0] ==
2269                     FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
2270                         zfcp_test_link(unit->port);
2271                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2272                 break;
2273         }
2274 skip_fsfstatus:
2275         if (req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
2276                 zfcp_fsf_send_fcp_ctm_handler(req);
2277         else {
2278                 zfcp_fsf_send_fcp_command_task_handler(req);
2279                 req->unit = NULL;
2280                 zfcp_unit_put(unit);
2281         }
2282 }
2283
2284 static void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, u32 fcp_dl)
2285 {
2286         u32 *fcp_dl_ptr;
2287
2288         /*
2289          * fcp_dl_addr = start address of fcp_cmnd structure +
2290          * size of fixed part + size of dynamically sized add_dcp_cdb field
2291          * SEE FCP-2 documentation
2292          */
2293         fcp_dl_ptr = (u32 *) ((unsigned char *) &fcp_cmd[1] +
2294                         (fcp_cmd->add_fcp_cdb_length << 2));
2295         *fcp_dl_ptr = fcp_dl;
2296 }
2297
2298 /**
2299  * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
2300  * @unit: unit where command is sent to
2301  * @scsi_cmnd: scsi command to be sent
2302  */
2303 int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
2304                                    struct scsi_cmnd *scsi_cmnd)
2305 {
2306         struct zfcp_fsf_req *req;
2307         struct fcp_cmnd_iu *fcp_cmnd_iu;
2308         unsigned int sbtype;
2309         int real_bytes, retval = -EIO;
2310         struct zfcp_adapter *adapter = unit->port->adapter;
2311
2312         if (unlikely(!(atomic_read(&unit->status) &
2313                        ZFCP_STATUS_COMMON_UNBLOCKED)))
2314                 return -EBUSY;
2315
2316         spin_lock(&adapter->req_q_lock);
2317         if (atomic_read(&adapter->req_q.count) <= 0) {
2318                 atomic_inc(&adapter->qdio_outb_full);
2319                 goto out;
2320         }
2321         req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND,
2322                                   ZFCP_REQ_AUTO_CLEANUP,
2323                                   adapter->pool.fsf_req_scsi);
2324         if (IS_ERR(req)) {
2325                 retval = PTR_ERR(req);
2326                 goto out;
2327         }
2328
2329         zfcp_unit_get(unit);
2330         req->unit = unit;
2331         req->data = scsi_cmnd;
2332         req->handler = zfcp_fsf_send_fcp_command_handler;
2333         req->qtcb->header.lun_handle = unit->handle;
2334         req->qtcb->header.port_handle = unit->port->handle;
2335         req->qtcb->bottom.io.service_class = FSF_CLASS_3;
2336
2337         scsi_cmnd->host_scribble = (unsigned char *) req->req_id;
2338
2339         fcp_cmnd_iu = (struct fcp_cmnd_iu *) &(req->qtcb->bottom.io.fcp_cmnd);
2340         fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
2341         /*
2342          * set depending on data direction:
2343          *      data direction bits in SBALE (SB Type)
2344          *      data direction bits in QTCB
2345          *      data direction bits in FCP_CMND IU
2346          */
2347         switch (scsi_cmnd->sc_data_direction) {
2348         case DMA_NONE:
2349                 req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
2350                 sbtype = SBAL_FLAGS0_TYPE_READ;
2351                 break;
2352         case DMA_FROM_DEVICE:
2353                 req->qtcb->bottom.io.data_direction = FSF_DATADIR_READ;
2354                 sbtype = SBAL_FLAGS0_TYPE_READ;
2355                 fcp_cmnd_iu->rddata = 1;
2356                 break;
2357         case DMA_TO_DEVICE:
2358                 req->qtcb->bottom.io.data_direction = FSF_DATADIR_WRITE;
2359                 sbtype = SBAL_FLAGS0_TYPE_WRITE;
2360                 fcp_cmnd_iu->wddata = 1;
2361                 break;
2362         case DMA_BIDIRECTIONAL:
2363         default:
2364                 retval = -EIO;
2365                 goto failed_scsi_cmnd;
2366         }
2367
2368         if (likely((scsi_cmnd->device->simple_tags) ||
2369                    ((atomic_read(&unit->status) & ZFCP_STATUS_UNIT_READONLY) &&
2370                     (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_SHARED))))
2371                 fcp_cmnd_iu->task_attribute = SIMPLE_Q;
2372         else
2373                 fcp_cmnd_iu->task_attribute = UNTAGGED;
2374
2375         if (unlikely(scsi_cmnd->cmd_len > FCP_CDB_LENGTH))
2376                 fcp_cmnd_iu->add_fcp_cdb_length =
2377                         (scsi_cmnd->cmd_len - FCP_CDB_LENGTH) >> 2;
2378
2379         memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
2380
2381         req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
2382                 fcp_cmnd_iu->add_fcp_cdb_length + sizeof(u32);
2383
2384         real_bytes = zfcp_qdio_sbals_from_sg(req, sbtype,
2385                                              scsi_sglist(scsi_cmnd),
2386                                              FSF_MAX_SBALS_PER_REQ);
2387         if (unlikely(real_bytes < 0)) {
2388                 if (req->sbal_number < FSF_MAX_SBALS_PER_REQ)
2389                         retval = -EIO;
2390                 else {
2391                         dev_err(&adapter->ccw_device->dev,
2392                                 "Oversize data package, unit 0x%016Lx "
2393                                 "on port 0x%016Lx closed\n",
2394                                 (unsigned long long)unit->fcp_lun,
2395                                 (unsigned long long)unit->port->wwpn);
2396                         zfcp_erp_unit_shutdown(unit, 0, "fssfct1", req);
2397                         retval = -EINVAL;
2398                 }
2399                 goto failed_scsi_cmnd;
2400         }
2401
2402         zfcp_set_fcp_dl(fcp_cmnd_iu, real_bytes);
2403
2404         retval = zfcp_fsf_req_send(req);
2405         if (unlikely(retval))
2406                 goto failed_scsi_cmnd;
2407
2408         goto out;
2409
2410 failed_scsi_cmnd:
2411         zfcp_unit_put(unit);
2412         zfcp_fsf_req_free(req);
2413         scsi_cmnd->host_scribble = NULL;
2414 out:
2415         spin_unlock(&adapter->req_q_lock);
2416         return retval;
2417 }
2418
2419 /**
2420  * zfcp_fsf_send_fcp_ctm - send SCSI task management command
2421  * @unit: pointer to struct zfcp_unit
2422  * @tm_flags: unsigned byte for task management flags
2423  * Returns: on success pointer to struct fsf_req, NULL otherwise
2424  */
2425 struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
2426 {
2427         struct qdio_buffer_element *sbale;
2428         struct zfcp_fsf_req *req = NULL;
2429         struct fcp_cmnd_iu *fcp_cmnd_iu;
2430         struct zfcp_adapter *adapter = unit->port->adapter;
2431
2432         if (unlikely(!(atomic_read(&unit->status) &
2433                        ZFCP_STATUS_COMMON_UNBLOCKED)))
2434                 return NULL;
2435
2436         spin_lock_bh(&adapter->req_q_lock);
2437         if (zfcp_fsf_req_sbal_get(adapter))
2438                 goto out;
2439         req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, 0,
2440                                   adapter->pool.fsf_req_scsi);
2441         if (IS_ERR(req)) {
2442                 req = NULL;
2443                 goto out;
2444         }
2445
2446         req->status |= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT;
2447         req->data = unit;
2448         req->handler = zfcp_fsf_send_fcp_command_handler;
2449         req->qtcb->header.lun_handle = unit->handle;
2450         req->qtcb->header.port_handle = unit->port->handle;
2451         req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
2452         req->qtcb->bottom.io.service_class = FSF_CLASS_3;
2453         req->qtcb->bottom.io.fcp_cmnd_length =  sizeof(struct fcp_cmnd_iu) +
2454                                                 sizeof(u32);
2455
2456         sbale = zfcp_qdio_sbale_req(req);
2457         sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
2458         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
2459
2460         fcp_cmnd_iu = (struct fcp_cmnd_iu *) &req->qtcb->bottom.io.fcp_cmnd;
2461         fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
2462         fcp_cmnd_iu->task_management_flags = tm_flags;
2463
2464         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
2465         if (!zfcp_fsf_req_send(req))
2466                 goto out;
2467
2468         zfcp_fsf_req_free(req);
2469         req = NULL;
2470 out:
2471         spin_unlock_bh(&adapter->req_q_lock);
2472         return req;
2473 }
2474
2475 static void zfcp_fsf_control_file_handler(struct zfcp_fsf_req *req)
2476 {
2477         if (req->qtcb->header.fsf_status != FSF_GOOD)
2478                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
2479 }
2480
2481 /**
2482  * zfcp_fsf_control_file - control file upload/download
2483  * @adapter: pointer to struct zfcp_adapter
2484  * @fsf_cfdc: pointer to struct zfcp_fsf_cfdc
2485  * Returns: on success pointer to struct zfcp_fsf_req, NULL otherwise
2486  */
2487 struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
2488                                            struct zfcp_fsf_cfdc *fsf_cfdc)
2489 {
2490         struct qdio_buffer_element *sbale;
2491         struct zfcp_fsf_req *req = NULL;
2492         struct fsf_qtcb_bottom_support *bottom;
2493         int direction, retval = -EIO, bytes;
2494
2495         if (!(adapter->adapter_features & FSF_FEATURE_CFDC))
2496                 return ERR_PTR(-EOPNOTSUPP);
2497
2498         switch (fsf_cfdc->command) {
2499         case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
2500                 direction = SBAL_FLAGS0_TYPE_WRITE;
2501                 break;
2502         case FSF_QTCB_UPLOAD_CONTROL_FILE:
2503                 direction = SBAL_FLAGS0_TYPE_READ;
2504                 break;
2505         default:
2506                 return ERR_PTR(-EINVAL);
2507         }
2508
2509         spin_lock_bh(&adapter->req_q_lock);
2510         if (zfcp_fsf_req_sbal_get(adapter))
2511                 goto out;
2512
2513         req = zfcp_fsf_req_create(adapter, fsf_cfdc->command, 0, NULL);
2514         if (IS_ERR(req)) {
2515                 retval = -EPERM;
2516                 goto out;
2517         }
2518
2519         req->handler = zfcp_fsf_control_file_handler;
2520
2521         sbale = zfcp_qdio_sbale_req(req);
2522         sbale[0].flags |= direction;
2523
2524         bottom = &req->qtcb->bottom.support;
2525         bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
2526         bottom->option = fsf_cfdc->option;
2527
2528         bytes = zfcp_qdio_sbals_from_sg(req, direction, fsf_cfdc->sg,
2529                                         FSF_MAX_SBALS_PER_REQ);
2530         if (bytes != ZFCP_CFDC_MAX_SIZE) {
2531                 retval = -ENOMEM;
2532                 zfcp_fsf_req_free(req);
2533                 goto out;
2534         }
2535
2536         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
2537         retval = zfcp_fsf_req_send(req);
2538 out:
2539         spin_unlock_bh(&adapter->req_q_lock);
2540
2541         if (!retval) {
2542                 wait_event(req->completion_wq,
2543                            req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
2544                 return req;
2545         }
2546         return ERR_PTR(retval);
2547 }