drivers/s390/scsi/zfcp_fsf.c

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