git.oblomov.eu Git - linux-2.6/blob - drivers/s390/scsi/zfcp_fsf.c

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