drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

   1 /*******************************************************************************
   2  * IBM Virtual SCSI Target Driver
   3  * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp.
   4  *                         Santiago Leon (santil@us.ibm.com) IBM Corp.
   5  *                         Linda Xie (lxie@us.ibm.com) IBM Corp.
   6  *
   7  * Copyright (C) 2005-2011 FUJITA Tomonori <tomof@acm.org>
   8  * Copyright (C) 2010 Nicholas A. Bellinger <nab@kernel.org>
   9  *
  10  * Authors: Bryant G. Ly <bryantly@linux.vnet.ibm.com>
  11  * Authors: Michael Cyr <mikecyr@linux.vnet.ibm.com>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  ****************************************************************************/
  24
  25 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
  26
  27 #include <linux/module.h>
  28 #include <linux/kernel.h>
  29 #include <linux/slab.h>
  30 #include <linux/types.h>
  31 #include <linux/list.h>
  32 #include <linux/string.h>
  33
  34 #include <target/target_core_base.h>
  35 #include <target/target_core_fabric.h>
  36
  37 #include <asm/hvcall.h>
  38 #include <asm/vio.h>
  39
  40 #include <scsi/viosrp.h>
  41
  42 #include "ibmvscsi_tgt.h"
  43
  44 #define IBMVSCSIS_VERSION       "v0.2"
  45
  46 #define INITIAL_SRP_LIMIT       800
  47 #define DEFAULT_MAX_SECTORS     256
  48
  49 static uint max_vdma_size = MAX_H_COPY_RDMA;
  50
  51 static char system_id[SYS_ID_NAME_LEN] = "";
  52 static char partition_name[PARTITION_NAMELEN] = "UNKNOWN";
  53 static uint partition_number = -1;
  54
  55 /* Adapter list and lock to control it */
  56 static DEFINE_SPINLOCK(ibmvscsis_dev_lock);
  57 static LIST_HEAD(ibmvscsis_dev_list);
  58
  59 static long ibmvscsis_parse_command(struct scsi_info *vscsi,
  60                                     struct viosrp_crq *crq);
  61
  62 static void ibmvscsis_adapter_idle(struct scsi_info *vscsi);
  63
  64 static void ibmvscsis_determine_resid(struct se_cmd *se_cmd,
  65                                       struct srp_rsp *rsp)
  66 {
  67         u32 residual_count = se_cmd->residual_count;
  68
  69         if (!residual_count)
  70                 return;
  71
  72         if (se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) {
  73                 if (se_cmd->data_direction == DMA_TO_DEVICE) {
  74                         /* residual data from an underflow write */
  75                         rsp->flags = SRP_RSP_FLAG_DOUNDER;
  76                         rsp->data_out_res_cnt = cpu_to_be32(residual_count);
  77                 } else if (se_cmd->data_direction == DMA_FROM_DEVICE) {
  78                         /* residual data from an underflow read */
  79                         rsp->flags = SRP_RSP_FLAG_DIUNDER;
  80                         rsp->data_in_res_cnt = cpu_to_be32(residual_count);
  81                 }
  82         } else if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
  83                 if (se_cmd->data_direction == DMA_TO_DEVICE) {
  84                         /*  residual data from an overflow write */
  85                         rsp->flags = SRP_RSP_FLAG_DOOVER;
  86                         rsp->data_out_res_cnt = cpu_to_be32(residual_count);
  87                 } else if (se_cmd->data_direction == DMA_FROM_DEVICE) {
  88                         /* residual data from an overflow read */
  89                         rsp->flags = SRP_RSP_FLAG_DIOVER;
  90                         rsp->data_in_res_cnt = cpu_to_be32(residual_count);
  91                 }
  92         }
  93 }
  94
  95 /**
  96  * connection_broken() - Determine if the connection to the client is good
  97  * @vscsi:      Pointer to our adapter structure
  98  *
  99  * This function attempts to send a ping MAD to the client. If the call to
 100  * queue the request returns H_CLOSED then the connection has been broken
 101  * and the function returns TRUE.
 102  *
 103  * EXECUTION ENVIRONMENT:
 104  *      Interrupt or Process environment
 105  */
 106 static bool connection_broken(struct scsi_info *vscsi)
 107 {
 108         struct viosrp_crq *crq;
 109         u64 buffer[2] = { 0, 0 };
 110         long h_return_code;
 111         bool rc = false;
 112
 113         /* create a PING crq */
 114         crq = (struct viosrp_crq *)&buffer;
 115         crq->valid = VALID_CMD_RESP_EL;
 116         crq->format = MESSAGE_IN_CRQ;
 117         crq->status = PING;
 118
 119         h_return_code = h_send_crq(vscsi->dds.unit_id,
 120                                    cpu_to_be64(buffer[MSG_HI]),
 121                                    cpu_to_be64(buffer[MSG_LOW]));
 122
 123         pr_debug("connection_broken: rc %ld\n", h_return_code);
 124
 125         if (h_return_code == H_CLOSED)
 126                 rc = true;
 127
 128         return rc;
 129 }
 130
 131 /**
 132  * ibmvscsis_unregister_command_q() - Helper Function-Unregister Command Queue
 133  * @vscsi:      Pointer to our adapter structure
 134  *
 135  * This function calls h_free_q then frees the interrupt bit etc.
 136  * It must release the lock before doing so because of the time it can take
 137  * for h_free_crq in PHYP
 138  * NOTE: the caller must make sure that state and or flags will prevent
 139  *       interrupt handler from scheduling work.
 140  * NOTE: anyone calling this function may need to set the CRQ_CLOSED flag
 141  *       we can't do it here, because we don't have the lock
 142  *
 143  * EXECUTION ENVIRONMENT:
 144  *      Process level
 145  */
 146 static long ibmvscsis_unregister_command_q(struct scsi_info *vscsi)
 147 {
 148         long qrc;
 149         long rc = ADAPT_SUCCESS;
 150         int ticks = 0;
 151
 152         do {
 153                 qrc = h_free_crq(vscsi->dds.unit_id);
 154                 switch (qrc) {
 155                 case H_SUCCESS:
 156                         break;
 157
 158                 case H_HARDWARE:
 159                 case H_PARAMETER:
 160                         dev_err(&vscsi->dev, "unregister_command_q: error from h_free_crq %ld\n",
 161                                 qrc);
 162                         rc = ERROR;
 163                         break;
 164
 165                 case H_BUSY:
 166                 case H_LONG_BUSY_ORDER_1_MSEC:
 167                         /* msleep not good for small values */
 168                         usleep_range(1000, 2000);
 169                         ticks += 1;
 170                         break;
 171                 case H_LONG_BUSY_ORDER_10_MSEC:
 172                         usleep_range(10000, 20000);
 173                         ticks += 10;
 174                         break;
 175                 case H_LONG_BUSY_ORDER_100_MSEC:
 176                         msleep(100);
 177                         ticks += 100;
 178                         break;
 179                 case H_LONG_BUSY_ORDER_1_SEC:
 180                         ssleep(1);
 181                         ticks += 1000;
 182                         break;
 183                 case H_LONG_BUSY_ORDER_10_SEC:
 184                         ssleep(10);
 185                         ticks += 10000;
 186                         break;
 187                 case H_LONG_BUSY_ORDER_100_SEC:
 188                         ssleep(100);
 189                         ticks += 100000;
 190                         break;
 191                 default:
 192                         dev_err(&vscsi->dev, "unregister_command_q: unknown error %ld from h_free_crq\n",
 193                                 qrc);
 194                         rc = ERROR;
 195                         break;
 196                 }
 197
 198                 /*
 199                  * dont wait more then 300 seconds
 200                  * ticks are in milliseconds more or less
 201                  */
 202                 if (ticks > 300000 && qrc != H_SUCCESS) {
 203                         rc = ERROR;
 204                         dev_err(&vscsi->dev, "Excessive wait for h_free_crq\n");
 205                 }
 206         } while (qrc != H_SUCCESS && rc == ADAPT_SUCCESS);
 207
 208         pr_debug("Freeing CRQ: phyp rc %ld, rc %ld\n", qrc, rc);
 209
 210         return rc;
 211 }
 212
 213 /**
 214  * ibmvscsis_delete_client_info() - Helper function to Delete Client Info
 215  * @vscsi:      Pointer to our adapter structure
 216  * @client_closed:      True if client closed its queue
 217  *
 218  * Deletes information specific to the client when the client goes away
 219  *
 220  * EXECUTION ENVIRONMENT:
 221  *      Interrupt or Process
 222  */
 223 static void ibmvscsis_delete_client_info(struct scsi_info *vscsi,
 224                                          bool client_closed)
 225 {
 226         vscsi->client_cap = 0;
 227
 228         /*
 229          * Some things we don't want to clear if we're closing the queue,
 230          * because some clients don't resend the host handshake when they
 231          * get a transport event.
 232          */
 233         if (client_closed)
 234                 vscsi->client_data.os_type = 0;
 235 }
 236
 237 /**
 238  * ibmvscsis_free_command_q() - Free Command Queue
 239  * @vscsi:      Pointer to our adapter structure
 240  *
 241  * This function calls unregister_command_q, then clears interrupts and
 242  * any pending interrupt acknowledgments associated with the command q.
 243  * It also clears memory if there is no error.
 244  *
 245  * PHYP did not meet the PAPR architecture so that we must give up the
 246  * lock. This causes a timing hole regarding state change.  To close the
 247  * hole this routine does accounting on any change that occurred during
 248  * the time the lock is not held.
 249  * NOTE: must give up and then acquire the interrupt lock, the caller must
 250  *       make sure that state and or flags will prevent interrupt handler from
 251  *       scheduling work.
 252  *
 253  * EXECUTION ENVIRONMENT:
 254  *      Process level, interrupt lock is held
 255  */
 256 static long ibmvscsis_free_command_q(struct scsi_info *vscsi)
 257 {
 258         int bytes;
 259         u32 flags_under_lock;
 260         u16 state_under_lock;
 261         long rc = ADAPT_SUCCESS;
 262
 263         if (!(vscsi->flags & CRQ_CLOSED)) {
 264                 vio_disable_interrupts(vscsi->dma_dev);
 265
 266                 state_under_lock = vscsi->new_state;
 267                 flags_under_lock = vscsi->flags;
 268                 vscsi->phyp_acr_state = 0;
 269                 vscsi->phyp_acr_flags = 0;
 270
 271                 spin_unlock_bh(&vscsi->intr_lock);
 272                 rc = ibmvscsis_unregister_command_q(vscsi);
 273                 spin_lock_bh(&vscsi->intr_lock);
 274
 275                 if (state_under_lock != vscsi->new_state)
 276                         vscsi->phyp_acr_state = vscsi->new_state;
 277
 278                 vscsi->phyp_acr_flags = ((~flags_under_lock) & vscsi->flags);
 279
 280                 if (rc == ADAPT_SUCCESS) {
 281                         bytes = vscsi->cmd_q.size * PAGE_SIZE;
 282                         memset(vscsi->cmd_q.base_addr, 0, bytes);
 283                         vscsi->cmd_q.index = 0;
 284                         vscsi->flags |= CRQ_CLOSED;
 285
 286                         ibmvscsis_delete_client_info(vscsi, false);
 287                 }
 288
 289                 pr_debug("free_command_q: flags 0x%x, state 0x%hx, acr_flags 0x%x, acr_state 0x%hx\n",
 290                          vscsi->flags, vscsi->state, vscsi->phyp_acr_flags,
 291                          vscsi->phyp_acr_state);
 292         }
 293         return rc;
 294 }
 295
 296 /**
 297  * ibmvscsis_cmd_q_dequeue() - Get valid Command element
 298  * @mask:       Mask to use in case index wraps
 299  * @current_index:      Current index into command queue
 300  * @base_addr:  Pointer to start of command queue
 301  *
 302  * Returns a pointer to a valid command element or NULL, if the command
 303  * queue is empty
 304  *
 305  * EXECUTION ENVIRONMENT:
 306  *      Interrupt environment, interrupt lock held
 307  */
 308 static struct viosrp_crq *ibmvscsis_cmd_q_dequeue(uint mask,
 309                                                   uint *current_index,
 310                                                   struct viosrp_crq *base_addr)
 311 {
 312         struct viosrp_crq *ptr;
 313
 314         ptr = base_addr + *current_index;
 315
 316         if (ptr->valid) {
 317                 *current_index = (*current_index + 1) & mask;
 318                 dma_rmb();
 319         } else {
 320                 ptr = NULL;
 321         }
 322
 323         return ptr;
 324 }
 325
 326 /**
 327  * ibmvscsis_send_init_message() -  send initialize message to the client
 328  * @vscsi:      Pointer to our adapter structure
 329  * @format:     Which Init Message format to send
 330  *
 331  * EXECUTION ENVIRONMENT:
 332  *      Interrupt environment interrupt lock held
 333  */
 334 static long ibmvscsis_send_init_message(struct scsi_info *vscsi, u8 format)
 335 {
 336         struct viosrp_crq *crq;
 337         u64 buffer[2] = { 0, 0 };
 338         long rc;
 339
 340         crq = (struct viosrp_crq *)&buffer;
 341         crq->valid = VALID_INIT_MSG;
 342         crq->format = format;
 343         rc = h_send_crq(vscsi->dds.unit_id, cpu_to_be64(buffer[MSG_HI]),
 344                         cpu_to_be64(buffer[MSG_LOW]));
 345
 346         return rc;
 347 }
 348
 349 /**
 350  * ibmvscsis_check_init_msg() - Check init message valid
 351  * @vscsi:      Pointer to our adapter structure
 352  * @format:     Pointer to return format of Init Message, if any.
 353  *              Set to UNUSED_FORMAT if no Init Message in queue.
 354  *
 355  * Checks if an initialize message was queued by the initiatior
 356  * after the queue was created and before the interrupt was enabled.
 357  *
 358  * EXECUTION ENVIRONMENT:
 359  *      Process level only, interrupt lock held
 360  */
 361 static long ibmvscsis_check_init_msg(struct scsi_info *vscsi, uint *format)
 362 {
 363         struct viosrp_crq *crq;
 364         long rc = ADAPT_SUCCESS;
 365
 366         crq = ibmvscsis_cmd_q_dequeue(vscsi->cmd_q.mask, &vscsi->cmd_q.index,
 367                                       vscsi->cmd_q.base_addr);
 368         if (!crq) {
 369                 *format = (uint)UNUSED_FORMAT;
 370         } else if (crq->valid == VALID_INIT_MSG && crq->format == INIT_MSG) {
 371                 *format = (uint)INIT_MSG;
 372                 crq->valid = INVALIDATE_CMD_RESP_EL;
 373                 dma_rmb();
 374
 375                 /*
 376                  * the caller has ensured no initialize message was
 377                  * sent after the queue was
 378                  * created so there should be no other message on the queue.
 379                  */
 380                 crq = ibmvscsis_cmd_q_dequeue(vscsi->cmd_q.mask,
 381                                               &vscsi->cmd_q.index,
 382                                               vscsi->cmd_q.base_addr);
 383                 if (crq) {
 384                         *format = (uint)(crq->format);
 385                         rc =  ERROR;
 386                         crq->valid = INVALIDATE_CMD_RESP_EL;
 387                         dma_rmb();
 388                 }
 389         } else {
 390                 *format = (uint)(crq->format);
 391                 rc =  ERROR;
 392                 crq->valid = INVALIDATE_CMD_RESP_EL;
 393                 dma_rmb();
 394         }
 395
 396         return rc;
 397 }
 398
 399 /**
 400  * ibmvscsis_establish_new_q() - Establish new CRQ queue
 401  * @vscsi:      Pointer to our adapter structure
 402  * @new_state:  New state being established after resetting the queue
 403  *
 404  * Must be called with interrupt lock held.
 405  */
 406 static long ibmvscsis_establish_new_q(struct scsi_info *vscsi,  uint new_state)
 407 {
 408         long rc = ADAPT_SUCCESS;
 409         uint format;
 410
 411         vscsi->flags &= PRESERVE_FLAG_FIELDS;
 412         vscsi->rsp_q_timer.timer_pops = 0;
 413         vscsi->debit = 0;
 414         vscsi->credit = 0;
 415
 416         rc = vio_enable_interrupts(vscsi->dma_dev);
 417         if (rc) {
 418                 pr_warn("reset_queue: failed to enable interrupts, rc %ld\n",
 419                         rc);
 420                 return rc;
 421         }
 422
 423         rc = ibmvscsis_check_init_msg(vscsi, &format);
 424         if (rc) {
 425                 dev_err(&vscsi->dev, "reset_queue: check_init_msg failed, rc %ld\n",
 426                         rc);
 427                 return rc;
 428         }
 429
 430         if (format == UNUSED_FORMAT && new_state == WAIT_CONNECTION) {
 431                 rc = ibmvscsis_send_init_message(vscsi, INIT_MSG);
 432                 switch (rc) {
 433                 case H_SUCCESS:
 434                 case H_DROPPED:
 435                 case H_CLOSED:
 436                         rc = ADAPT_SUCCESS;
 437                         break;
 438
 439                 case H_PARAMETER:
 440                 case H_HARDWARE:
 441                         break;
 442
 443                 default:
 444                         vscsi->state = UNDEFINED;
 445                         rc = H_HARDWARE;
 446                         break;
 447                 }
 448         }
 449
 450         return rc;
 451 }
 452
 453 /**
 454  * ibmvscsis_reset_queue() - Reset CRQ Queue
 455  * @vscsi:      Pointer to our adapter structure
 456  * @new_state:  New state to establish after resetting the queue
 457  *
 458  * This function calls h_free_q and then calls h_reg_q and does all
 459  * of the bookkeeping to get us back to where we can communicate.
 460  *
 461  * Actually, we don't always call h_free_crq.  A problem was discovered
 462  * where one partition would close and reopen his queue, which would
 463  * cause his partner to get a transport event, which would cause him to
 464  * close and reopen his queue, which would cause the original partition
 465  * to get a transport event, etc., etc.  To prevent this, we don't
 466  * actually close our queue if the client initiated the reset, (i.e.
 467  * either we got a transport event or we have detected that the client's
 468  * queue is gone)
 469  *
 470  * EXECUTION ENVIRONMENT:
 471  *      Process environment, called with interrupt lock held
 472  */
 473 static void ibmvscsis_reset_queue(struct scsi_info *vscsi, uint new_state)
 474 {
 475         int bytes;
 476         long rc = ADAPT_SUCCESS;
 477
 478         pr_debug("reset_queue: flags 0x%x\n", vscsi->flags);
 479
 480         /* don't reset, the client did it for us */
 481         if (vscsi->flags & (CLIENT_FAILED | TRANS_EVENT)) {
 482                 vscsi->flags &=  PRESERVE_FLAG_FIELDS;
 483                 vscsi->rsp_q_timer.timer_pops = 0;
 484                 vscsi->debit = 0;
 485                 vscsi->credit = 0;
 486                 vscsi->state = new_state;
 487                 vio_enable_interrupts(vscsi->dma_dev);
 488         } else {
 489                 rc = ibmvscsis_free_command_q(vscsi);
 490                 if (rc == ADAPT_SUCCESS) {
 491                         vscsi->state = new_state;
 492
 493                         bytes = vscsi->cmd_q.size * PAGE_SIZE;
 494                         rc = h_reg_crq(vscsi->dds.unit_id,
 495                                        vscsi->cmd_q.crq_token, bytes);
 496                         if (rc == H_CLOSED || rc == H_SUCCESS) {
 497                                 rc = ibmvscsis_establish_new_q(vscsi,
 498                                                                new_state);
 499                         }
 500
 501                         if (rc != ADAPT_SUCCESS) {
 502                                 pr_debug("reset_queue: reg_crq rc %ld\n", rc);
 503
 504                                 vscsi->state = ERR_DISCONNECTED;
 505                                 vscsi->flags |=  RESPONSE_Q_DOWN;
 506                                 ibmvscsis_free_command_q(vscsi);
 507                         }
 508                 } else {
 509                         vscsi->state = ERR_DISCONNECTED;
 510                         vscsi->flags |= RESPONSE_Q_DOWN;
 511                 }
 512         }
 513 }
 514
 515 /**
 516  * ibmvscsis_free_cmd_resources() - Free command resources
 517  * @vscsi:      Pointer to our adapter structure
 518  * @cmd:        Command which is not longer in use
 519  *
 520  * Must be called with interrupt lock held.
 521  */
 522 static void ibmvscsis_free_cmd_resources(struct scsi_info *vscsi,
 523                                          struct ibmvscsis_cmd *cmd)
 524 {
 525         struct iu_entry *iue = cmd->iue;
 526
 527         switch (cmd->type) {
 528         case TASK_MANAGEMENT:
 529         case SCSI_CDB:
 530                 /*
 531                  * When the queue goes down this value is cleared, so it
 532                  * cannot be cleared in this general purpose function.
 533                  */
 534                 if (vscsi->debit)
 535                         vscsi->debit -= 1;
 536                 break;
 537         case ADAPTER_MAD:
 538                 vscsi->flags &= ~PROCESSING_MAD;
 539                 break;
 540         case UNSET_TYPE:
 541                 break;
 542         default:
 543                 dev_err(&vscsi->dev, "free_cmd_resources unknown type %d\n",
 544                         cmd->type);
 545                 break;
 546         }
 547
 548         cmd->iue = NULL;
 549         list_add_tail(&cmd->list, &vscsi->free_cmd);
 550         srp_iu_put(iue);
 551
 552         if (list_empty(&vscsi->active_q) && list_empty(&vscsi->schedule_q) &&
 553             list_empty(&vscsi->waiting_rsp) && (vscsi->flags & WAIT_FOR_IDLE)) {
 554                 vscsi->flags &= ~WAIT_FOR_IDLE;
 555                 complete(&vscsi->wait_idle);
 556         }
 557 }
 558
 559 /**
 560  * ibmvscsis_disconnect() - Helper function to disconnect
 561  * @work:       Pointer to work_struct, gives access to our adapter structure
 562  *
 563  * An error has occurred or the driver received a Transport event,
 564  * and the driver is requesting that the command queue be de-registered
 565  * in a safe manner. If there is no outstanding I/O then we can stop the
 566  * queue. If we are restarting the queue it will be reflected in the
 567  * the state of the adapter.
 568  *
 569  * EXECUTION ENVIRONMENT:
 570  *      Process environment
 571  */
 572 static void ibmvscsis_disconnect(struct work_struct *work)
 573 {
 574         struct scsi_info *vscsi = container_of(work, struct scsi_info,
 575                                                proc_work);
 576         u16 new_state;
 577         bool wait_idle = false;
 578         long rc = ADAPT_SUCCESS;
 579
 580         spin_lock_bh(&vscsi->intr_lock);
 581         new_state = vscsi->new_state;
 582         vscsi->new_state = 0;
 583
 584         pr_debug("disconnect: flags 0x%x, state 0x%hx\n", vscsi->flags,
 585                  vscsi->state);
 586
 587         /*
 588          * check which state we are in and see if we
 589          * should transitition to the new state
 590          */
 591         switch (vscsi->state) {
 592         /*  Should never be called while in this state. */
 593         case NO_QUEUE:
 594         /*
 595          * Can never transition from this state;
 596          * igonore errors and logout.
 597          */
 598         case UNCONFIGURING:
 599                 break;
 600
 601         /* can transition from this state to UNCONFIGURING */
 602         case ERR_DISCONNECT:
 603                 if (new_state == UNCONFIGURING)
 604                         vscsi->state = new_state;
 605                 break;
 606
 607         /*
 608          * Can transition from this state to to unconfiguring
 609          * or err disconnect.
 610          */
 611         case ERR_DISCONNECT_RECONNECT:
 612                 switch (new_state) {
 613                 case UNCONFIGURING:
 614                 case ERR_DISCONNECT:
 615                         vscsi->state = new_state;
 616                         break;
 617
 618                 case WAIT_IDLE:
 619                         break;
 620                 default:
 621                         break;
 622                 }
 623                 break;
 624
 625         /* can transition from this state to UNCONFIGURING */
 626         case ERR_DISCONNECTED:
 627                 if (new_state == UNCONFIGURING)
 628                         vscsi->state = new_state;
 629                 break;
 630
 631         /*
 632          * If this is a transition into an error state.
 633          * a client is attempting to establish a connection
 634          * and has violated the RPA protocol.
 635          * There can be nothing pending on the adapter although
 636          * there can be requests in the command queue.
 637          */
 638         case WAIT_ENABLED:
 639         case PART_UP_WAIT_ENAB:
 640                 switch (new_state) {
 641                 case ERR_DISCONNECT:
 642                         vscsi->flags |= RESPONSE_Q_DOWN;
 643                         vscsi->state = new_state;
 644                         vscsi->flags &= ~(SCHEDULE_DISCONNECT |
 645                                           DISCONNECT_SCHEDULED);
 646                         ibmvscsis_free_command_q(vscsi);
 647                         break;
 648                 case ERR_DISCONNECT_RECONNECT:
 649                         ibmvscsis_reset_queue(vscsi, WAIT_ENABLED);
 650                         break;
 651
 652                 /* should never happen */
 653                 case WAIT_IDLE:
 654                         rc = ERROR;
 655                         dev_err(&vscsi->dev, "disconnect: invalid state %d for WAIT_IDLE\n",
 656                                 vscsi->state);
 657                         break;
 658                 }
 659                 break;
 660
 661         case WAIT_IDLE:
 662                 switch (new_state) {
 663                 case ERR_DISCONNECT:
 664                 case ERR_DISCONNECT_RECONNECT:
 665                         vscsi->state = new_state;
 666                         break;
 667                 }
 668                 break;
 669
 670         /*
 671          * Initiator has not done a successful srp login
 672          * or has done a successful srp logout ( adapter was not
 673          * busy). In the first case there can be responses queued
 674          * waiting for space on the initiators response queue (MAD)
 675          * The second case the adapter is idle. Assume the worse case,
 676          * i.e. the second case.
 677          */
 678         case WAIT_CONNECTION:
 679         case CONNECTED:
 680         case SRP_PROCESSING:
 681                 wait_idle = true;
 682                 vscsi->state = new_state;
 683                 break;
 684
 685         /* can transition from this state to UNCONFIGURING */
 686         case UNDEFINED:
 687                 if (new_state == UNCONFIGURING)
 688                         vscsi->state = new_state;
 689                 break;
 690         default:
 691                 break;
 692         }
 693
 694         if (wait_idle) {
 695                 pr_debug("disconnect start wait, active %d, sched %d\n",
 696                          (int)list_empty(&vscsi->active_q),
 697                          (int)list_empty(&vscsi->schedule_q));
 698                 if (!list_empty(&vscsi->active_q) ||
 699                     !list_empty(&vscsi->schedule_q)) {
 700                         vscsi->flags |= WAIT_FOR_IDLE;
 701                         pr_debug("disconnect flags 0x%x\n", vscsi->flags);
 702                         /*
 703                          * This routine is can not be called with the interrupt
 704                          * lock held.
 705                          */
 706                         spin_unlock_bh(&vscsi->intr_lock);
 707                         wait_for_completion(&vscsi->wait_idle);
 708                         spin_lock_bh(&vscsi->intr_lock);
 709                 }
 710                 pr_debug("disconnect stop wait\n");
 711
 712                 ibmvscsis_adapter_idle(vscsi);
 713         }
 714
 715         spin_unlock_bh(&vscsi->intr_lock);
 716 }
 717
 718 /**
 719  * ibmvscsis_post_disconnect() - Schedule the disconnect
 720  * @vscsi:      Pointer to our adapter structure
 721  * @new_state:  State to move to after disconnecting
 722  * @flag_bits:  Flags to turn on in adapter structure
 723  *
 724  * If it's already been scheduled, then see if we need to "upgrade"
 725  * the new state (if the one passed in is more "severe" than the
 726  * previous one).
 727  *
 728  * PRECONDITION:
 729  *      interrupt lock is held
 730  */
 731 static void ibmvscsis_post_disconnect(struct scsi_info *vscsi, uint new_state,
 732                                       uint flag_bits)
 733 {
 734         uint state;
 735
 736         /* check the validity of the new state */
 737         switch (new_state) {
 738         case UNCONFIGURING:
 739         case ERR_DISCONNECT:
 740         case ERR_DISCONNECT_RECONNECT:
 741         case WAIT_IDLE:
 742                 break;
 743
 744         default:
 745                 dev_err(&vscsi->dev, "post_disconnect: Invalid new state %d\n",
 746                         new_state);
 747                 return;
 748         }
 749
 750         vscsi->flags |= flag_bits;
 751
 752         pr_debug("post_disconnect: new_state 0x%x, flag_bits 0x%x, vscsi->flags 0x%x, state %hx\n",
 753                  new_state, flag_bits, vscsi->flags, vscsi->state);
 754
 755         if (!(vscsi->flags & (DISCONNECT_SCHEDULED | SCHEDULE_DISCONNECT))) {
 756                 vscsi->flags |= SCHEDULE_DISCONNECT;
 757                 vscsi->new_state = new_state;
 758
 759                 INIT_WORK(&vscsi->proc_work, ibmvscsis_disconnect);
 760                 (void)queue_work(vscsi->work_q, &vscsi->proc_work);
 761         } else {
 762                 if (vscsi->new_state)
 763                         state = vscsi->new_state;
 764                 else
 765                         state = vscsi->state;
 766
 767                 switch (state) {
 768                 case NO_QUEUE:
 769                 case UNCONFIGURING:
 770                         break;
 771
 772                 case ERR_DISCONNECTED:
 773                 case ERR_DISCONNECT:
 774                 case UNDEFINED:
 775                         if (new_state == UNCONFIGURING)
 776                                 vscsi->new_state = new_state;
 777                         break;
 778
 779                 case ERR_DISCONNECT_RECONNECT:
 780                         switch (new_state) {
 781                         case UNCONFIGURING:
 782                         case ERR_DISCONNECT:
 783                                 vscsi->new_state = new_state;
 784                                 break;
 785                         default:
 786                                 break;
 787                         }
 788                         break;
 789
 790                 case WAIT_ENABLED:
 791                 case PART_UP_WAIT_ENAB:
 792                 case WAIT_IDLE:
 793                 case WAIT_CONNECTION:
 794                 case CONNECTED:
 795                 case SRP_PROCESSING:
 796                         vscsi->new_state = new_state;
 797                         break;
 798
 799                 default:
 800                         break;
 801                 }
 802         }
 803
 804         pr_debug("Leaving post_disconnect: flags 0x%x, new_state 0x%x\n",
 805                  vscsi->flags, vscsi->new_state);
 806 }
 807
 808 /**
 809  * ibmvscsis_trans_event() - Handle a Transport Event
 810  * @vscsi:      Pointer to our adapter structure
 811  * @crq:        Pointer to CRQ entry containing the Transport Event
 812  *
 813  * Do the logic to close the I_T nexus.  This function may not
 814  * behave to specification.
 815  *
 816  * EXECUTION ENVIRONMENT:
 817  *      Interrupt, interrupt lock held
 818  */
 819 static long ibmvscsis_trans_event(struct scsi_info *vscsi,
 820                                   struct viosrp_crq *crq)
 821 {
 822         long rc = ADAPT_SUCCESS;
 823
 824         pr_debug("trans_event: format %d, flags 0x%x, state 0x%hx\n",
 825                  (int)crq->format, vscsi->flags, vscsi->state);
 826
 827         switch (crq->format) {
 828         case MIGRATED:
 829         case PARTNER_FAILED:
 830         case PARTNER_DEREGISTER:
 831                 ibmvscsis_delete_client_info(vscsi, true);
 832                 break;
 833
 834         default:
 835                 rc = ERROR;
 836                 dev_err(&vscsi->dev, "trans_event: invalid format %d\n",
 837                         (uint)crq->format);
 838                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT,
 839                                           RESPONSE_Q_DOWN);
 840                 break;
 841         }
 842
 843         if (rc == ADAPT_SUCCESS) {
 844                 switch (vscsi->state) {
 845                 case NO_QUEUE:
 846                 case ERR_DISCONNECTED:
 847                 case UNDEFINED:
 848                         break;
 849
 850                 case UNCONFIGURING:
 851                         vscsi->flags |= (RESPONSE_Q_DOWN | TRANS_EVENT);
 852                         break;
 853
 854                 case WAIT_ENABLED:
 855                         break;
 856
 857                 case WAIT_CONNECTION:
 858                         break;
 859
 860                 case CONNECTED:
 861                         ibmvscsis_post_disconnect(vscsi, WAIT_IDLE,
 862                                                   (RESPONSE_Q_DOWN |
 863                                                    TRANS_EVENT));
 864                         break;
 865
 866                 case PART_UP_WAIT_ENAB:
 867                         vscsi->state = WAIT_ENABLED;
 868                         break;
 869
 870                 case SRP_PROCESSING:
 871                         if ((vscsi->debit > 0) ||
 872                             !list_empty(&vscsi->schedule_q) ||
 873                             !list_empty(&vscsi->waiting_rsp) ||
 874                             !list_empty(&vscsi->active_q)) {
 875                                 pr_debug("debit %d, sched %d, wait %d, active %d\n",
 876                                          vscsi->debit,
 877                                          (int)list_empty(&vscsi->schedule_q),
 878                                          (int)list_empty(&vscsi->waiting_rsp),
 879                                          (int)list_empty(&vscsi->active_q));
 880                                 pr_warn("connection lost with outstanding work\n");
 881                         } else {
 882                                 pr_debug("trans_event: SRP Processing, but no outstanding work\n");
 883                         }
 884
 885                         ibmvscsis_post_disconnect(vscsi, WAIT_IDLE,
 886                                                   (RESPONSE_Q_DOWN |
 887                                                    TRANS_EVENT));
 888                         break;
 889
 890                 case ERR_DISCONNECT:
 891                 case ERR_DISCONNECT_RECONNECT:
 892                 case WAIT_IDLE:
 893                         vscsi->flags |= (RESPONSE_Q_DOWN | TRANS_EVENT);
 894                         break;
 895                 }
 896         }
 897
 898         rc =  vscsi->flags & SCHEDULE_DISCONNECT;
 899
 900         pr_debug("Leaving trans_event: flags 0x%x, state 0x%hx, rc %ld\n",
 901                  vscsi->flags, vscsi->state, rc);
 902
 903         return rc;
 904 }
 905
 906 /**
 907  * ibmvscsis_poll_cmd_q() - Poll Command Queue
 908  * @vscsi:      Pointer to our adapter structure
 909  *
 910  * Called to handle command elements that may have arrived while
 911  * interrupts were disabled.
 912  *
 913  * EXECUTION ENVIRONMENT:
 914  *      intr_lock must be held
 915  */
 916 static void ibmvscsis_poll_cmd_q(struct scsi_info *vscsi)
 917 {
 918         struct viosrp_crq *crq;
 919         long rc;
 920         bool ack = true;
 921         volatile u8 valid;
 922
 923         pr_debug("poll_cmd_q: flags 0x%x, state 0x%hx, q index %ud\n",
 924                  vscsi->flags, vscsi->state, vscsi->cmd_q.index);
 925
 926         rc = vscsi->flags & SCHEDULE_DISCONNECT;
 927         crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index;
 928         valid = crq->valid;
 929         dma_rmb();
 930
 931         while (valid) {
 932 poll_work:
 933                 vscsi->cmd_q.index =
 934                         (vscsi->cmd_q.index + 1) & vscsi->cmd_q.mask;
 935
 936                 if (!rc) {
 937                         rc = ibmvscsis_parse_command(vscsi, crq);
 938                 } else {
 939                         if ((uint)crq->valid == VALID_TRANS_EVENT) {
 940                                 /*
 941                                  * must service the transport layer events even
 942                                  * in an error state, dont break out until all
 943                                  * the consecutive transport events have been
 944                                  * processed
 945                                  */
 946                                 rc = ibmvscsis_trans_event(vscsi, crq);
 947                         } else if (vscsi->flags & TRANS_EVENT) {
 948                                 /*
 949                                  * if a tranport event has occurred leave
 950                                  * everything but transport events on the queue
 951                                  */
 952                                 pr_debug("poll_cmd_q, ignoring\n");
 953
 954                                 /*
 955                                  * need to decrement the queue index so we can
 956                                  * look at the elment again
 957                                  */
 958                                 if (vscsi->cmd_q.index)
 959                                         vscsi->cmd_q.index -= 1;
 960                                 else
 961                                         /*
 962                                          * index is at 0 it just wrapped.
 963                                          * have it index last element in q
 964                                          */
 965                                         vscsi->cmd_q.index = vscsi->cmd_q.mask;
 966                                 break;
 967                         }
 968                 }
 969
 970                 crq->valid = INVALIDATE_CMD_RESP_EL;
 971
 972                 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index;
 973                 valid = crq->valid;
 974                 dma_rmb();
 975         }
 976
 977         if (!rc) {
 978                 if (ack) {
 979                         vio_enable_interrupts(vscsi->dma_dev);
 980                         ack = false;
 981                         pr_debug("poll_cmd_q, reenabling interrupts\n");
 982                 }
 983                 valid = crq->valid;
 984                 dma_rmb();
 985                 if (valid)
 986                         goto poll_work;
 987         }
 988
 989         pr_debug("Leaving poll_cmd_q: rc %ld\n", rc);
 990 }
 991
 992 /**
 993  * ibmvscsis_free_cmd_qs() - Free elements in queue
 994  * @vscsi:      Pointer to our adapter structure
 995  *
 996  * Free all of the elements on all queues that are waiting for
 997  * whatever reason.
 998  *
 999  * PRECONDITION:
1000  *      Called with interrupt lock held
1001  */
1002 static void ibmvscsis_free_cmd_qs(struct scsi_info *vscsi)
1003 {
1004         struct ibmvscsis_cmd *cmd, *nxt;
1005
1006         pr_debug("free_cmd_qs: waiting_rsp empty %d, timer starter %d\n",
1007                  (int)list_empty(&vscsi->waiting_rsp),
1008                  vscsi->rsp_q_timer.started);
1009
1010         list_for_each_entry_safe(cmd, nxt, &vscsi->waiting_rsp, list) {
1011                 list_del(&cmd->list);
1012                 ibmvscsis_free_cmd_resources(vscsi, cmd);
1013         }
1014 }
1015
1016 /**
1017  * ibmvscsis_get_free_cmd() - Get free command from list
1018  * @vscsi:      Pointer to our adapter structure
1019  *
1020  * Must be called with interrupt lock held.
1021  */
1022 static struct ibmvscsis_cmd *ibmvscsis_get_free_cmd(struct scsi_info *vscsi)
1023 {
1024         struct ibmvscsis_cmd *cmd = NULL;
1025         struct iu_entry *iue;
1026
1027         iue = srp_iu_get(&vscsi->target);
1028         if (iue) {
1029                 cmd = list_first_entry_or_null(&vscsi->free_cmd,
1030                                                struct ibmvscsis_cmd, list);
1031                 if (cmd) {
1032                         list_del(&cmd->list);
1033                         cmd->iue = iue;
1034                         cmd->type = UNSET_TYPE;
1035                         memset(&cmd->se_cmd, 0, sizeof(cmd->se_cmd));
1036                 } else {
1037                         srp_iu_put(iue);
1038                 }
1039         }
1040
1041         return cmd;
1042 }
1043
1044 /**
1045  * ibmvscsis_adapter_idle() - Helper function to handle idle adapter
1046  * @vscsi:      Pointer to our adapter structure
1047  *
1048  * This function is called when the adapter is idle when the driver
1049  * is attempting to clear an error condition.
1050  * The adapter is considered busy if any of its cmd queues
1051  * are non-empty. This function can be invoked
1052  * from the off level disconnect function.
1053  *
1054  * EXECUTION ENVIRONMENT:
1055  *      Process environment called with interrupt lock held
1056  */
1057 static void ibmvscsis_adapter_idle(struct scsi_info *vscsi)
1058 {
1059         int free_qs = false;
1060
1061         pr_debug("adapter_idle: flags 0x%x, state 0x%hx\n", vscsi->flags,
1062                  vscsi->state);
1063
1064         /* Only need to free qs if we're disconnecting from client */
1065         if (vscsi->state != WAIT_CONNECTION || vscsi->flags & TRANS_EVENT)
1066                 free_qs = true;
1067
1068         switch (vscsi->state) {
1069         case ERR_DISCONNECT_RECONNECT:
1070                 ibmvscsis_reset_queue(vscsi, WAIT_CONNECTION);
1071                 pr_debug("adapter_idle, disc_rec: flags 0x%x\n", vscsi->flags);
1072                 break;
1073
1074         case ERR_DISCONNECT:
1075                 ibmvscsis_free_command_q(vscsi);
1076                 vscsi->flags &= ~DISCONNECT_SCHEDULED;
1077                 vscsi->flags |= RESPONSE_Q_DOWN;
1078                 vscsi->state = ERR_DISCONNECTED;
1079                 pr_debug("adapter_idle, disc: flags 0x%x, state 0x%hx\n",
1080                          vscsi->flags, vscsi->state);
1081                 break;
1082
1083         case WAIT_IDLE:
1084                 vscsi->rsp_q_timer.timer_pops = 0;
1085                 vscsi->debit = 0;
1086                 vscsi->credit = 0;
1087                 if (vscsi->flags & TRANS_EVENT) {
1088                         vscsi->state = WAIT_CONNECTION;
1089                         vscsi->flags &= PRESERVE_FLAG_FIELDS;
1090                 } else {
1091                         vscsi->state = CONNECTED;
1092                         vscsi->flags &= ~DISCONNECT_SCHEDULED;
1093                 }
1094
1095                 pr_debug("adapter_idle, wait: flags 0x%x, state 0x%hx\n",
1096                          vscsi->flags, vscsi->state);
1097                 ibmvscsis_poll_cmd_q(vscsi);
1098                 break;
1099
1100         case ERR_DISCONNECTED:
1101                 vscsi->flags &= ~DISCONNECT_SCHEDULED;
1102                 pr_debug("adapter_idle, disconnected: flags 0x%x, state 0x%hx\n",
1103                          vscsi->flags, vscsi->state);
1104                 break;
1105
1106         default:
1107                 dev_err(&vscsi->dev, "adapter_idle: in invalid state %d\n",
1108                         vscsi->state);
1109                 break;
1110         }
1111
1112         if (free_qs)
1113                 ibmvscsis_free_cmd_qs(vscsi);
1114
1115         /*
1116          * There is a timing window where we could lose a disconnect request.
1117          * The known path to this window occurs during the DISCONNECT_RECONNECT
1118          * case above: reset_queue calls free_command_q, which will release the
1119          * interrupt lock.  During that time, a new post_disconnect call can be
1120          * made with a "more severe" state (DISCONNECT or UNCONFIGURING).
1121          * Because the DISCONNECT_SCHEDULED flag is already set, post_disconnect
1122          * will only set the new_state.  Now free_command_q reacquires the intr
1123          * lock and clears the DISCONNECT_SCHEDULED flag (using PRESERVE_FLAG_
1124          * FIELDS), and the disconnect is lost.  This is particularly bad when
1125          * the new disconnect was for UNCONFIGURING, since the unconfigure hangs
1126          * forever.
1127          * Fix is that free command queue sets acr state and acr flags if there
1128          * is a change under the lock
1129          * note free command queue writes to this state it clears it
1130          * before releasing the lock, different drivers call the free command
1131          * queue different times so dont initialize above
1132          */
1133         if (vscsi->phyp_acr_state != 0) {
1134                 /*
1135                  * set any bits in flags that may have been cleared by
1136                  * a call to free command queue in switch statement
1137                  * or reset queue
1138                  */
1139                 vscsi->flags |= vscsi->phyp_acr_flags;
1140                 ibmvscsis_post_disconnect(vscsi, vscsi->phyp_acr_state, 0);
1141                 vscsi->phyp_acr_state = 0;
1142                 vscsi->phyp_acr_flags = 0;
1143
1144                 pr_debug("adapter_idle: flags 0x%x, state 0x%hx, acr_flags 0x%x, acr_state 0x%hx\n",
1145                          vscsi->flags, vscsi->state, vscsi->phyp_acr_flags,
1146                          vscsi->phyp_acr_state);
1147         }
1148
1149         pr_debug("Leaving adapter_idle: flags 0x%x, state 0x%hx, new_state 0x%x\n",
1150                  vscsi->flags, vscsi->state, vscsi->new_state);
1151 }
1152
1153 /**
1154  * ibmvscsis_copy_crq_packet() - Copy CRQ Packet
1155  * @vscsi:      Pointer to our adapter structure
1156  * @cmd:        Pointer to command element to use to process the request
1157  * @crq:        Pointer to CRQ entry containing the request
1158  *
1159  * Copy the srp information unit from the hosted
1160  * partition using remote dma
1161  *
1162  * EXECUTION ENVIRONMENT:
1163  *      Interrupt, interrupt lock held
1164  */
1165 static long ibmvscsis_copy_crq_packet(struct scsi_info *vscsi,
1166                                       struct ibmvscsis_cmd *cmd,
1167                                       struct viosrp_crq *crq)
1168 {
1169         struct iu_entry *iue = cmd->iue;
1170         long rc = 0;
1171         u16 len;
1172
1173         len = be16_to_cpu(crq->IU_length);
1174         if ((len > SRP_MAX_IU_LEN) || (len == 0)) {
1175                 dev_err(&vscsi->dev, "copy_crq: Invalid len %d passed", len);
1176                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
1177                 return SRP_VIOLATION;
1178         }
1179
1180         rc = h_copy_rdma(len, vscsi->dds.window[REMOTE].liobn,
1181                          be64_to_cpu(crq->IU_data_ptr),
1182                          vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma);
1183
1184         switch (rc) {
1185         case H_SUCCESS:
1186                 cmd->init_time = mftb();
1187                 iue->remote_token = crq->IU_data_ptr;
1188                 iue->iu_len = len;
1189                 pr_debug("copy_crq: ioba 0x%llx, init_time 0x%llx\n",
1190                          be64_to_cpu(crq->IU_data_ptr), cmd->init_time);
1191                 break;
1192         case H_PERMISSION:
1193                 if (connection_broken(vscsi))
1194                         ibmvscsis_post_disconnect(vscsi,
1195                                                   ERR_DISCONNECT_RECONNECT,
1196                                                   (RESPONSE_Q_DOWN |
1197                                                    CLIENT_FAILED));
1198                 else
1199                         ibmvscsis_post_disconnect(vscsi,
1200                                                   ERR_DISCONNECT_RECONNECT, 0);
1201
1202                 dev_err(&vscsi->dev, "copy_crq: h_copy_rdma failed, rc %ld\n",
1203                         rc);
1204                 break;
1205         case H_DEST_PARM:
1206         case H_SOURCE_PARM:
1207         default:
1208                 dev_err(&vscsi->dev, "copy_crq: h_copy_rdma failed, rc %ld\n",
1209                         rc);
1210                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
1211                 break;
1212         }
1213
1214         return rc;
1215 }
1216
1217 /**
1218  * ibmvscsis_adapter_info - Service an Adapter Info MAnagement Data gram
1219  * @vscsi:      Pointer to our adapter structure
1220  * @iue:        Information Unit containing the Adapter Info MAD request
1221  *
1222  * EXECUTION ENVIRONMENT:
1223  *      Interrupt adpater lock is held
1224  */
1225 static long ibmvscsis_adapter_info(struct scsi_info *vscsi,
1226                                    struct iu_entry *iue)
1227 {
1228         struct viosrp_adapter_info *mad = &vio_iu(iue)->mad.adapter_info;
1229         struct mad_adapter_info_data *info;
1230         uint flag_bits = 0;
1231         dma_addr_t token;
1232         long rc;
1233
1234         mad->common.status = cpu_to_be16(VIOSRP_MAD_SUCCESS);
1235
1236         if (be16_to_cpu(mad->common.length) > sizeof(*info)) {
1237                 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED);
1238                 return 0;
1239         }
1240
1241         info = dma_alloc_coherent(&vscsi->dma_dev->dev, sizeof(*info), &token,
1242                                   GFP_KERNEL);
1243         if (!info) {
1244                 dev_err(&vscsi->dev, "bad dma_alloc_coherent %p\n",
1245                         iue->target);
1246                 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED);
1247                 return 0;
1248         }
1249
1250         /* Get remote info */
1251         rc = h_copy_rdma(be16_to_cpu(mad->common.length),
1252                          vscsi->dds.window[REMOTE].liobn,
1253                          be64_to_cpu(mad->buffer),
1254                          vscsi->dds.window[LOCAL].liobn, token);
1255
1256         if (rc != H_SUCCESS) {
1257                 if (rc == H_PERMISSION) {
1258                         if (connection_broken(vscsi))
1259                                 flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED);
1260                 }
1261                 pr_warn("adapter_info: h_copy_rdma from client failed, rc %ld\n",
1262                         rc);
1263                 pr_debug("adapter_info: ioba 0x%llx, flags 0x%x, flag_bits 0x%x\n",
1264                          be64_to_cpu(mad->buffer), vscsi->flags, flag_bits);
1265                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT,
1266                                           flag_bits);
1267                 goto free_dma;
1268         }
1269
1270         /*
1271          * Copy client info, but ignore partition number, which we
1272          * already got from phyp - unless we failed to get it from
1273          * phyp (e.g. if we're running on a p5 system).
1274          */
1275         if (vscsi->client_data.partition_number == 0)
1276                 vscsi->client_data.partition_number =
1277                         be32_to_cpu(info->partition_number);
1278         strncpy(vscsi->client_data.srp_version, info->srp_version,
1279                 sizeof(vscsi->client_data.srp_version));
1280         strncpy(vscsi->client_data.partition_name, info->partition_name,
1281                 sizeof(vscsi->client_data.partition_name));
1282         vscsi->client_data.mad_version = be32_to_cpu(info->mad_version);
1283         vscsi->client_data.os_type = be32_to_cpu(info->os_type);
1284
1285         /* Copy our info */
1286         strncpy(info->srp_version, SRP_VERSION,
1287                 sizeof(info->srp_version));
1288         strncpy(info->partition_name, vscsi->dds.partition_name,
1289                 sizeof(info->partition_name));
1290         info->partition_number = cpu_to_be32(vscsi->dds.partition_num);
1291         info->mad_version = cpu_to_be32(MAD_VERSION_1);
1292         info->os_type = cpu_to_be32(LINUX);
1293         memset(&info->port_max_txu[0], 0, sizeof(info->port_max_txu));
1294         info->port_max_txu[0] = cpu_to_be32(128 * PAGE_SIZE);
1295
1296         dma_wmb();
1297         rc = h_copy_rdma(sizeof(*info), vscsi->dds.window[LOCAL].liobn,
1298                          token, vscsi->dds.window[REMOTE].liobn,
1299                          be64_to_cpu(mad->buffer));
1300         switch (rc) {
1301         case H_SUCCESS:
1302                 break;
1303
1304         case H_SOURCE_PARM:
1305         case H_DEST_PARM:
1306         case H_PERMISSION:
1307                 if (connection_broken(vscsi))
1308                         flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED);
1309         default:
1310                 dev_err(&vscsi->dev, "adapter_info: h_copy_rdma to client failed, rc %ld\n",
1311                         rc);
1312                 ibmvscsis_post_disconnect(vscsi,
1313                                           ERR_DISCONNECT_RECONNECT,
1314                                           flag_bits);
1315                 break;
1316         }
1317
1318 free_dma:
1319         dma_free_coherent(&vscsi->dma_dev->dev, sizeof(*info), info, token);
1320         pr_debug("Leaving adapter_info, rc %ld\n", rc);
1321
1322         return rc;
1323 }
1324
1325 /**
1326  * ibmvscsis_cap_mad() - Service a Capabilities MAnagement Data gram
1327  * @vscsi:      Pointer to our adapter structure
1328  * @iue:        Information Unit containing the Capabilities MAD request
1329  *
1330  * NOTE: if you return an error from this routine you must be
1331  * disconnecting or you will cause a hang
1332  *
1333  * EXECUTION ENVIRONMENT:
1334  *      Interrupt called with adapter lock held
1335  */
1336 static int ibmvscsis_cap_mad(struct scsi_info *vscsi, struct iu_entry *iue)
1337 {
1338         struct viosrp_capabilities *mad = &vio_iu(iue)->mad.capabilities;
1339         struct capabilities *cap;
1340         struct mad_capability_common *common;
1341         dma_addr_t token;
1342         u16 olen, len, status, min_len, cap_len;
1343         u32 flag;
1344         uint flag_bits = 0;
1345         long rc = 0;
1346
1347         olen = be16_to_cpu(mad->common.length);
1348         /*
1349          * struct capabilities hardcodes a couple capabilities after the
1350          * header, but the capabilities can actually be in any order.
1351          */
1352         min_len = offsetof(struct capabilities, migration);
1353         if ((olen < min_len) || (olen > PAGE_SIZE)) {
1354                 pr_warn("cap_mad: invalid len %d\n", olen);
1355                 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED);
1356                 return 0;
1357         }
1358
1359         cap = dma_alloc_coherent(&vscsi->dma_dev->dev, olen, &token,
1360                                  GFP_KERNEL);
1361         if (!cap) {
1362                 dev_err(&vscsi->dev, "bad dma_alloc_coherent %p\n",
1363                         iue->target);
1364                 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED);
1365                 return 0;
1366         }
1367         rc = h_copy_rdma(olen, vscsi->dds.window[REMOTE].liobn,
1368                          be64_to_cpu(mad->buffer),
1369                          vscsi->dds.window[LOCAL].liobn, token);
1370         if (rc == H_SUCCESS) {
1371                 strncpy(cap->name, dev_name(&vscsi->dma_dev->dev),
1372                         SRP_MAX_LOC_LEN);
1373
1374                 len = olen - min_len;
1375                 status = VIOSRP_MAD_SUCCESS;
1376                 common = (struct mad_capability_common *)&cap->migration;
1377
1378                 while ((len > 0) && (status == VIOSRP_MAD_SUCCESS) && !rc) {
1379                         pr_debug("cap_mad: len left %hd, cap type %d, cap len %hd\n",
1380                                  len, be32_to_cpu(common->cap_type),
1381                                  be16_to_cpu(common->length));
1382
1383                         cap_len = be16_to_cpu(common->length);
1384                         if (cap_len > len) {
1385                                 dev_err(&vscsi->dev, "cap_mad: cap len mismatch with total len\n");
1386                                 status = VIOSRP_MAD_FAILED;
1387                                 break;
1388                         }
1389
1390                         if (cap_len == 0) {
1391                                 dev_err(&vscsi->dev, "cap_mad: cap len is 0\n");
1392                                 status = VIOSRP_MAD_FAILED;
1393                                 break;
1394                         }
1395
1396                         switch (common->cap_type) {
1397                         default:
1398                                 pr_debug("cap_mad: unsupported capability\n");
1399                                 common->server_support = 0;
1400                                 flag = cpu_to_be32((u32)CAP_LIST_SUPPORTED);
1401                                 cap->flags &= ~flag;
1402                                 break;
1403                         }
1404
1405                         len = len - cap_len;
1406                         common = (struct mad_capability_common *)
1407                                 ((char *)common + cap_len);
1408                 }
1409
1410                 mad->common.status = cpu_to_be16(status);
1411
1412                 dma_wmb();
1413                 rc = h_copy_rdma(olen, vscsi->dds.window[LOCAL].liobn, token,
1414                                  vscsi->dds.window[REMOTE].liobn,
1415                                  be64_to_cpu(mad->buffer));
1416
1417                 if (rc != H_SUCCESS) {
1418                         pr_debug("cap_mad: failed to copy to client, rc %ld\n",
1419                                  rc);
1420
1421                         if (rc == H_PERMISSION) {
1422                                 if (connection_broken(vscsi))
1423                                         flag_bits = (RESPONSE_Q_DOWN |
1424                                                      CLIENT_FAILED);
1425                         }
1426
1427                         pr_warn("cap_mad: error copying data to client, rc %ld\n",
1428                                 rc);
1429                         ibmvscsis_post_disconnect(vscsi,
1430                                                   ERR_DISCONNECT_RECONNECT,
1431                                                   flag_bits);
1432                 }
1433         }
1434
1435         dma_free_coherent(&vscsi->dma_dev->dev, olen, cap, token);
1436
1437         pr_debug("Leaving cap_mad, rc %ld, client_cap 0x%x\n",
1438                  rc, vscsi->client_cap);
1439
1440         return rc;
1441 }
1442
1443 /**
1444  * ibmvscsis_process_mad() - Service a MAnagement Data gram
1445  * @vscsi:      Pointer to our adapter structure
1446  * @iue:        Information Unit containing the MAD request
1447  *
1448  * Must be called with interrupt lock held.
1449  */
1450 static long ibmvscsis_process_mad(struct scsi_info *vscsi, struct iu_entry *iue)
1451 {
1452         struct mad_common *mad = (struct mad_common *)&vio_iu(iue)->mad;
1453         struct viosrp_empty_iu *empty;
1454         long rc = ADAPT_SUCCESS;
1455
1456         switch (be32_to_cpu(mad->type)) {
1457         case VIOSRP_EMPTY_IU_TYPE:
1458                 empty = &vio_iu(iue)->mad.empty_iu;
1459                 vscsi->empty_iu_id = be64_to_cpu(empty->buffer);
1460                 vscsi->empty_iu_tag = be64_to_cpu(empty->common.tag);
1461                 mad->status = cpu_to_be16(VIOSRP_MAD_SUCCESS);
1462                 break;
1463         case VIOSRP_ADAPTER_INFO_TYPE:
1464                 rc = ibmvscsis_adapter_info(vscsi, iue);
1465                 break;
1466         case VIOSRP_CAPABILITIES_TYPE:
1467                 rc = ibmvscsis_cap_mad(vscsi, iue);
1468                 break;
1469         case VIOSRP_ENABLE_FAST_FAIL:
1470                 if (vscsi->state == CONNECTED) {
1471                         vscsi->fast_fail = true;
1472                         mad->status = cpu_to_be16(VIOSRP_MAD_SUCCESS);
1473                 } else {
1474                         pr_warn("fast fail mad sent after login\n");
1475                         mad->status = cpu_to_be16(VIOSRP_MAD_FAILED);
1476                 }
1477                 break;
1478         default:
1479                 mad->status = cpu_to_be16(VIOSRP_MAD_NOT_SUPPORTED);
1480                 break;
1481         }
1482
1483         return rc;
1484 }
1485
1486 /**
1487  * srp_snd_msg_failed() - Handle an error when sending a response
1488  * @vscsi:      Pointer to our adapter structure
1489  * @rc:         The return code from the h_send_crq command
1490  *
1491  * Must be called with interrupt lock held.
1492  */
1493 static void srp_snd_msg_failed(struct scsi_info *vscsi, long rc)
1494 {
1495         ktime_t kt;
1496
1497         if (rc != H_DROPPED) {
1498                 ibmvscsis_free_cmd_qs(vscsi);
1499
1500                 if (rc == H_CLOSED)
1501                         vscsi->flags |= CLIENT_FAILED;
1502
1503                 /* don't flag the same problem multiple times */
1504                 if (!(vscsi->flags & RESPONSE_Q_DOWN)) {
1505                         vscsi->flags |= RESPONSE_Q_DOWN;
1506                         if (!(vscsi->state & (ERR_DISCONNECT |
1507                                               ERR_DISCONNECT_RECONNECT |
1508                                               ERR_DISCONNECTED | UNDEFINED))) {
1509                                 dev_err(&vscsi->dev, "snd_msg_failed: setting RESPONSE_Q_DOWN, state 0x%hx, flags 0x%x, rc %ld\n",
1510                                         vscsi->state, vscsi->flags, rc);
1511                         }
1512                         ibmvscsis_post_disconnect(vscsi,
1513                                                   ERR_DISCONNECT_RECONNECT, 0);
1514                 }
1515                 return;
1516         }
1517
1518         /*
1519          * The response queue is full.
1520          * If the server is processing SRP requests, i.e.
1521          * the client has successfully done an
1522          * SRP_LOGIN, then it will wait forever for room in
1523          * the queue.  However if the system admin
1524          * is attempting to unconfigure the server then one
1525          * or more children will be in a state where
1526          * they are being removed. So if there is even one
1527          * child being removed then the driver assumes
1528          * the system admin is attempting to break the
1529          * connection with the client and MAX_TIMER_POPS
1530          * is honored.
1531          */
1532         if ((vscsi->rsp_q_timer.timer_pops < MAX_TIMER_POPS) ||
1533             (vscsi->state == SRP_PROCESSING)) {
1534                 pr_debug("snd_msg_failed: response queue full, flags 0x%x, timer started %d, pops %d\n",
1535                          vscsi->flags, (int)vscsi->rsp_q_timer.started,
1536                          vscsi->rsp_q_timer.timer_pops);
1537
1538                 /*
1539                  * Check if the timer is running; if it
1540                  * is not then start it up.
1541                  */
1542                 if (!vscsi->rsp_q_timer.started) {
1543                         if (vscsi->rsp_q_timer.timer_pops <
1544                             MAX_TIMER_POPS) {
1545                                 kt = ktime_set(0, WAIT_NANO_SECONDS);
1546                         } else {
1547                                 /*
1548                                  * slide the timeslice if the maximum
1549                                  * timer pops have already happened
1550                                  */
1551                                 kt = ktime_set(WAIT_SECONDS, 0);
1552                         }
1553
1554                         vscsi->rsp_q_timer.started = true;
1555                         hrtimer_start(&vscsi->rsp_q_timer.timer, kt,
1556                                       HRTIMER_MODE_REL);
1557                 }
1558         } else {
1559                 /*
1560                  * TBD: Do we need to worry about this? Need to get
1561                  *      remove working.
1562                  */
1563                 /*
1564                  * waited a long time and it appears the system admin
1565                  * is bring this driver down
1566                  */
1567                 vscsi->flags |= RESPONSE_Q_DOWN;
1568                 ibmvscsis_free_cmd_qs(vscsi);
1569                 /*
1570                  * if the driver is already attempting to disconnect
1571                  * from the client and has already logged an error
1572                  * trace this event but don't put it in the error log
1573                  */
1574                 if (!(vscsi->state & (ERR_DISCONNECT |
1575                                       ERR_DISCONNECT_RECONNECT |
1576                                       ERR_DISCONNECTED | UNDEFINED))) {
1577                         dev_err(&vscsi->dev, "client crq full too long\n");
1578                         ibmvscsis_post_disconnect(vscsi,
1579                                                   ERR_DISCONNECT_RECONNECT,
1580                                                   0);
1581                 }
1582         }
1583 }
1584
1585 /**
1586  * ibmvscsis_send_messages() - Send a Response
1587  * @vscsi:      Pointer to our adapter structure
1588  *
1589  * Send a response, first checking the waiting queue. Responses are
1590  * sent in order they are received. If the response cannot be sent,
1591  * because the client queue is full, it stays on the waiting queue.
1592  *
1593  * PRECONDITION:
1594  *      Called with interrupt lock held
1595  */
1596 static void ibmvscsis_send_messages(struct scsi_info *vscsi)
1597 {
1598         u64 msg_hi = 0;
1599         /* note do not attmempt to access the IU_data_ptr with this pointer
1600          * it is not valid
1601          */
1602         struct viosrp_crq *crq = (struct viosrp_crq *)&msg_hi;
1603         struct ibmvscsis_cmd *cmd, *nxt;
1604         struct iu_entry *iue;
1605         long rc = ADAPT_SUCCESS;
1606
1607         if (!(vscsi->flags & RESPONSE_Q_DOWN)) {
1608                 list_for_each_entry_safe(cmd, nxt, &vscsi->waiting_rsp, list) {
1609                         iue = cmd->iue;
1610
1611                         crq->valid = VALID_CMD_RESP_EL;
1612                         crq->format = cmd->rsp.format;
1613
1614                         if (cmd->flags & CMD_FAST_FAIL)
1615                                 crq->status = VIOSRP_ADAPTER_FAIL;
1616
1617                         crq->IU_length = cpu_to_be16(cmd->rsp.len);
1618
1619                         rc = h_send_crq(vscsi->dma_dev->unit_address,
1620                                         be64_to_cpu(msg_hi),
1621                                         be64_to_cpu(cmd->rsp.tag));
1622
1623                         pr_debug("send_messages: tag 0x%llx, rc %ld\n",
1624                                  be64_to_cpu(cmd->rsp.tag), rc);
1625
1626                         /* if all ok free up the command element resources */
1627                         if (rc == H_SUCCESS) {
1628                                 /* some movement has occurred */
1629                                 vscsi->rsp_q_timer.timer_pops = 0;
1630                                 list_del(&cmd->list);
1631
1632                                 ibmvscsis_free_cmd_resources(vscsi, cmd);
1633                         } else {
1634                                 srp_snd_msg_failed(vscsi, rc);
1635                                 break;
1636                         }
1637                 }
1638
1639                 if (!rc) {
1640                         /*
1641                          * The timer could pop with the queue empty.  If
1642                          * this happens, rc will always indicate a
1643                          * success; clear the pop count.
1644                          */
1645                         vscsi->rsp_q_timer.timer_pops = 0;
1646                 }
1647         } else {
1648                 ibmvscsis_free_cmd_qs(vscsi);
1649         }
1650 }
1651
1652 /* Called with intr lock held */
1653 static void ibmvscsis_send_mad_resp(struct scsi_info *vscsi,
1654                                     struct ibmvscsis_cmd *cmd,
1655                                     struct viosrp_crq *crq)
1656 {
1657         struct iu_entry *iue = cmd->iue;
1658         struct mad_common *mad = (struct mad_common *)&vio_iu(iue)->mad;
1659         uint flag_bits = 0;
1660         long rc;
1661
1662         dma_wmb();
1663         rc = h_copy_rdma(sizeof(struct mad_common),
1664                          vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma,
1665                          vscsi->dds.window[REMOTE].liobn,
1666                          be64_to_cpu(crq->IU_data_ptr));
1667         if (!rc) {
1668                 cmd->rsp.format = VIOSRP_MAD_FORMAT;
1669                 cmd->rsp.len = sizeof(struct mad_common);
1670                 cmd->rsp.tag = mad->tag;
1671                 list_add_tail(&cmd->list, &vscsi->waiting_rsp);
1672                 ibmvscsis_send_messages(vscsi);
1673         } else {
1674                 pr_debug("Error sending mad response, rc %ld\n", rc);
1675                 if (rc == H_PERMISSION) {
1676                         if (connection_broken(vscsi))
1677                                 flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED);
1678                 }
1679                 dev_err(&vscsi->dev, "mad: failed to copy to client, rc %ld\n",
1680                         rc);
1681
1682                 ibmvscsis_free_cmd_resources(vscsi, cmd);
1683                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT,
1684                                           flag_bits);
1685         }
1686 }
1687
1688 /**
1689  * ibmvscsis_mad() - Service a MAnagement Data gram.
1690  * @vscsi:      Pointer to our adapter structure
1691  * @crq:        Pointer to the CRQ entry containing the MAD request
1692  *
1693  * EXECUTION ENVIRONMENT:
1694  *      Interrupt  called with adapter lock held
1695  */
1696 static long ibmvscsis_mad(struct scsi_info *vscsi, struct viosrp_crq *crq)
1697 {
1698         struct iu_entry *iue;
1699         struct ibmvscsis_cmd *cmd;
1700         struct mad_common *mad;
1701         long rc = ADAPT_SUCCESS;
1702
1703         switch (vscsi->state) {
1704                 /*
1705                  * We have not exchanged Init Msgs yet, so this MAD was sent
1706                  * before the last Transport Event; client will not be
1707                  * expecting a response.
1708                  */
1709         case WAIT_CONNECTION:
1710                 pr_debug("mad: in Wait Connection state, ignoring MAD, flags %d\n",
1711                          vscsi->flags);
1712                 return ADAPT_SUCCESS;
1713
1714         case SRP_PROCESSING:
1715         case CONNECTED:
1716                 break;
1717
1718                 /*
1719                  * We should never get here while we're in these states.
1720                  * Just log an error and get out.
1721                  */
1722         case UNCONFIGURING:
1723         case WAIT_IDLE:
1724         case ERR_DISCONNECT:
1725         case ERR_DISCONNECT_RECONNECT:
1726         default:
1727                 dev_err(&vscsi->dev, "mad: invalid adapter state %d for mad\n",
1728                         vscsi->state);
1729                 return ADAPT_SUCCESS;
1730         }
1731
1732         cmd = ibmvscsis_get_free_cmd(vscsi);
1733         if (!cmd) {
1734                 dev_err(&vscsi->dev, "mad: failed to get cmd, debit %d\n",
1735                         vscsi->debit);
1736                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
1737                 return ERROR;
1738         }
1739         iue = cmd->iue;
1740         cmd->type = ADAPTER_MAD;
1741
1742         rc = ibmvscsis_copy_crq_packet(vscsi, cmd, crq);
1743         if (!rc) {
1744                 mad = (struct mad_common *)&vio_iu(iue)->mad;
1745
1746                 pr_debug("mad: type %d\n", be32_to_cpu(mad->type));
1747
1748                 if (be16_to_cpu(mad->length) < 0) {
1749                         dev_err(&vscsi->dev, "mad: length is < 0\n");
1750                         ibmvscsis_post_disconnect(vscsi,
1751                                                   ERR_DISCONNECT_RECONNECT, 0);
1752                         rc = SRP_VIOLATION;
1753                 } else {
1754                         rc = ibmvscsis_process_mad(vscsi, iue);
1755                 }
1756
1757                 pr_debug("mad: status %hd, rc %ld\n", be16_to_cpu(mad->status),
1758                          rc);
1759
1760                 if (!rc)
1761                         ibmvscsis_send_mad_resp(vscsi, cmd, crq);
1762         } else {
1763                 ibmvscsis_free_cmd_resources(vscsi, cmd);
1764         }
1765
1766         pr_debug("Leaving mad, rc %ld\n", rc);
1767         return rc;
1768 }
1769
1770 /**
1771  * ibmvscsis_login_rsp() - Create/copy a login response notice to the client
1772  * @vscsi:      Pointer to our adapter structure
1773  * @cmd:        Pointer to the command for the SRP Login request
1774  *
1775  * EXECUTION ENVIRONMENT:
1776  *      Interrupt, interrupt lock held
1777  */
1778 static long ibmvscsis_login_rsp(struct scsi_info *vscsi,
1779                                 struct ibmvscsis_cmd *cmd)
1780 {
1781         struct iu_entry *iue = cmd->iue;
1782         struct srp_login_rsp *rsp = &vio_iu(iue)->srp.login_rsp;
1783         struct format_code *fmt;
1784         uint flag_bits = 0;
1785         long rc = ADAPT_SUCCESS;
1786
1787         memset(rsp, 0, sizeof(struct srp_login_rsp));
1788
1789         rsp->opcode = SRP_LOGIN_RSP;
1790         rsp->req_lim_delta = cpu_to_be32(vscsi->request_limit);
1791         rsp->tag = cmd->rsp.tag;
1792         rsp->max_it_iu_len = cpu_to_be32(SRP_MAX_IU_LEN);
1793         rsp->max_ti_iu_len = cpu_to_be32(SRP_MAX_IU_LEN);
1794         fmt = (struct format_code *)&rsp->buf_fmt;
1795         fmt->buffers = SUPPORTED_FORMATS;
1796         vscsi->credit = 0;
1797
1798         cmd->rsp.len = sizeof(struct srp_login_rsp);
1799
1800         dma_wmb();
1801         rc = h_copy_rdma(cmd->rsp.len, vscsi->dds.window[LOCAL].liobn,
1802                          iue->sbuf->dma, vscsi->dds.window[REMOTE].liobn,
1803                          be64_to_cpu(iue->remote_token));
1804
1805         switch (rc) {
1806         case H_SUCCESS:
1807                 break;
1808
1809         case H_PERMISSION:
1810                 if (connection_broken(vscsi))
1811                         flag_bits = RESPONSE_Q_DOWN | CLIENT_FAILED;
1812                 dev_err(&vscsi->dev, "login_rsp: error copying to client, rc %ld\n",
1813                         rc);
1814                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT,
1815                                           flag_bits);
1816                 break;
1817         case H_SOURCE_PARM:
1818         case H_DEST_PARM:
1819         default:
1820                 dev_err(&vscsi->dev, "login_rsp: error copying to client, rc %ld\n",
1821                         rc);
1822                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
1823                 break;
1824         }
1825
1826         return rc;
1827 }
1828
1829 /**
1830  * ibmvscsis_srp_login_rej() - Create/copy a login rejection notice to client
1831  * @vscsi:      Pointer to our adapter structure
1832  * @cmd:        Pointer to the command for the SRP Login request
1833  * @reason:     The reason the SRP Login is being rejected, per SRP protocol
1834  *
1835  * EXECUTION ENVIRONMENT:
1836  *      Interrupt, interrupt lock held
1837  */
1838 static long ibmvscsis_srp_login_rej(struct scsi_info *vscsi,
1839                                     struct ibmvscsis_cmd *cmd, u32 reason)
1840 {
1841         struct iu_entry *iue = cmd->iue;
1842         struct srp_login_rej *rej = &vio_iu(iue)->srp.login_rej;
1843         struct format_code *fmt;
1844         uint flag_bits = 0;
1845         long rc = ADAPT_SUCCESS;
1846
1847         memset(rej, 0, sizeof(*rej));
1848
1849         rej->opcode = SRP_LOGIN_REJ;
1850         rej->reason = cpu_to_be32(reason);
1851         rej->tag = cmd->rsp.tag;
1852         fmt = (struct format_code *)&rej->buf_fmt;
1853         fmt->buffers = SUPPORTED_FORMATS;
1854
1855         cmd->rsp.len = sizeof(*rej);
1856
1857         dma_wmb();
1858         rc = h_copy_rdma(cmd->rsp.len, vscsi->dds.window[LOCAL].liobn,
1859                          iue->sbuf->dma, vscsi->dds.window[REMOTE].liobn,
1860                          be64_to_cpu(iue->remote_token));
1861
1862         switch (rc) {
1863         case H_SUCCESS:
1864                 break;
1865         case H_PERMISSION:
1866                 if (connection_broken(vscsi))
1867                         flag_bits =  RESPONSE_Q_DOWN | CLIENT_FAILED;
1868                 dev_err(&vscsi->dev, "login_rej: error copying to client, rc %ld\n",
1869                         rc);
1870                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT,
1871                                           flag_bits);
1872                 break;
1873         case H_SOURCE_PARM:
1874         case H_DEST_PARM:
1875         default:
1876                 dev_err(&vscsi->dev, "login_rej: error copying to client, rc %ld\n",
1877                         rc);
1878                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
1879                 break;
1880         }
1881
1882         return rc;
1883 }
1884
1885 static int ibmvscsis_make_nexus(struct ibmvscsis_tport *tport)
1886 {
1887         char *name = tport->tport_name;
1888         struct ibmvscsis_nexus *nexus;
1889         int rc;
1890
1891         if (tport->ibmv_nexus) {
1892                 pr_debug("tport->ibmv_nexus already exists\n");
1893                 return 0;
1894         }
1895
1896         nexus = kzalloc(sizeof(*nexus), GFP_KERNEL);
1897         if (!nexus) {
1898                 pr_err("Unable to allocate struct ibmvscsis_nexus\n");
1899                 return -ENOMEM;
1900         }
1901
1902         nexus->se_sess = target_alloc_session(&tport->se_tpg, 0, 0,
1903                                               TARGET_PROT_NORMAL, name, nexus,
1904                                               NULL);
1905         if (IS_ERR(nexus->se_sess)) {
1906                 rc = PTR_ERR(nexus->se_sess);
1907                 goto transport_init_fail;
1908         }
1909
1910         tport->ibmv_nexus = nexus;
1911
1912         return 0;
1913
1914 transport_init_fail:
1915         kfree(nexus);
1916         return rc;
1917 }
1918
1919 static int ibmvscsis_drop_nexus(struct ibmvscsis_tport *tport)
1920 {
1921         struct se_session *se_sess;
1922         struct ibmvscsis_nexus *nexus;
1923
1924         nexus = tport->ibmv_nexus;
1925         if (!nexus)
1926                 return -ENODEV;
1927
1928         se_sess = nexus->se_sess;
1929         if (!se_sess)
1930                 return -ENODEV;
1931
1932         /*
1933          * Release the SCSI I_T Nexus to the emulated ibmvscsis Target Port
1934          */
1935         target_wait_for_sess_cmds(se_sess);
1936         transport_deregister_session_configfs(se_sess);
1937         transport_deregister_session(se_sess);
1938         tport->ibmv_nexus = NULL;
1939         kfree(nexus);
1940
1941         return 0;
1942 }
1943
1944 /**
1945  * ibmvscsis_srp_login() - Process an SRP Login Request
1946  * @vscsi:      Pointer to our adapter structure
1947  * @cmd:        Command element to use to process the SRP Login request
1948  * @crq:        Pointer to CRQ entry containing the SRP Login request
1949  *
1950  * EXECUTION ENVIRONMENT:
1951  *      Interrupt, called with interrupt lock held
1952  */
1953 static long ibmvscsis_srp_login(struct scsi_info *vscsi,
1954                                 struct ibmvscsis_cmd *cmd,
1955                                 struct viosrp_crq *crq)
1956 {
1957         struct iu_entry *iue = cmd->iue;
1958         struct srp_login_req *req = &vio_iu(iue)->srp.login_req;
1959         struct port_id {
1960                 __be64 id_extension;
1961                 __be64 io_guid;
1962         } *iport, *tport;
1963         struct format_code *fmt;
1964         u32 reason = 0x0;
1965         long rc = ADAPT_SUCCESS;
1966
1967         iport = (struct port_id *)req->initiator_port_id;
1968         tport = (struct port_id *)req->target_port_id;
1969         fmt = (struct format_code *)&req->req_buf_fmt;
1970         if (be32_to_cpu(req->req_it_iu_len) > SRP_MAX_IU_LEN)
1971                 reason = SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE;
1972         else if (be32_to_cpu(req->req_it_iu_len) < 64)
1973                 reason = SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL;
1974         else if ((be64_to_cpu(iport->id_extension) > (MAX_NUM_PORTS - 1)) ||
1975                  (be64_to_cpu(tport->id_extension) > (MAX_NUM_PORTS - 1)))
1976                 reason = SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL;
1977         else if (req->req_flags & SRP_MULTICHAN_MULTI)
1978                 reason = SRP_LOGIN_REJ_MULTI_CHANNEL_UNSUPPORTED;
1979         else if (fmt->buffers & (~SUPPORTED_FORMATS))
1980                 reason = SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT;
1981         else if ((fmt->buffers & SUPPORTED_FORMATS) == 0)
1982                 reason = SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT;
1983
1984         if (vscsi->state == SRP_PROCESSING)
1985                 reason = SRP_LOGIN_REJ_CHANNEL_LIMIT_REACHED;
1986
1987         rc = ibmvscsis_make_nexus(&vscsi->tport);
1988         if (rc)
1989                 reason = SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL;
1990
1991         cmd->rsp.format = VIOSRP_SRP_FORMAT;
1992         cmd->rsp.tag = req->tag;
1993
1994         pr_debug("srp_login: reason 0x%x\n", reason);
1995
1996         if (reason)
1997                 rc = ibmvscsis_srp_login_rej(vscsi, cmd, reason);
1998         else
1999                 rc = ibmvscsis_login_rsp(vscsi, cmd);
2000
2001         if (!rc) {
2002                 if (!reason)
2003                         vscsi->state = SRP_PROCESSING;
2004
2005                 list_add_tail(&cmd->list, &vscsi->waiting_rsp);
2006                 ibmvscsis_send_messages(vscsi);
2007         } else {
2008                 ibmvscsis_free_cmd_resources(vscsi, cmd);
2009         }
2010
2011         pr_debug("Leaving srp_login, rc %ld\n", rc);
2012         return rc;
2013 }
2014
2015 /**
2016  * ibmvscsis_srp_i_logout() - Helper Function to close I_T Nexus
2017  * @vscsi:      Pointer to our adapter structure
2018  * @cmd:        Command element to use to process the Implicit Logout request
2019  * @crq:        Pointer to CRQ entry containing the Implicit Logout request
2020  *
2021  * Do the logic to close the I_T nexus.  This function may not
2022  * behave to specification.
2023  *
2024  * EXECUTION ENVIRONMENT:
2025  *      Interrupt, interrupt lock held
2026  */
2027 static long ibmvscsis_srp_i_logout(struct scsi_info *vscsi,
2028                                    struct ibmvscsis_cmd *cmd,
2029                                    struct viosrp_crq *crq)
2030 {
2031         struct iu_entry *iue = cmd->iue;
2032         struct srp_i_logout *log_out = &vio_iu(iue)->srp.i_logout;
2033         long rc = ADAPT_SUCCESS;
2034
2035         if ((vscsi->debit > 0) || !list_empty(&vscsi->schedule_q) ||
2036             !list_empty(&vscsi->waiting_rsp)) {
2037                 dev_err(&vscsi->dev, "i_logout: outstanding work\n");
2038                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0);
2039         } else {
2040                 cmd->rsp.format = SRP_FORMAT;
2041                 cmd->rsp.tag = log_out->tag;
2042                 cmd->rsp.len = sizeof(struct mad_common);
2043                 list_add_tail(&cmd->list, &vscsi->waiting_rsp);
2044                 ibmvscsis_send_messages(vscsi);
2045
2046                 ibmvscsis_post_disconnect(vscsi, WAIT_IDLE, 0);
2047         }
2048
2049         return rc;
2050 }
2051
2052 /* Called with intr lock held */
2053 static void ibmvscsis_srp_cmd(struct scsi_info *vscsi, struct viosrp_crq *crq)
2054 {
2055         struct ibmvscsis_cmd *cmd;
2056         struct iu_entry *iue;
2057         struct srp_cmd *srp;
2058         struct srp_tsk_mgmt *tsk;
2059         long rc;
2060
2061         if (vscsi->request_limit - vscsi->debit <= 0) {
2062                 /* Client has exceeded request limit */
2063                 dev_err(&vscsi->dev, "Client exceeded the request limit (%d), debit %d\n",
2064                         vscsi->request_limit, vscsi->debit);
2065                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2066                 return;
2067         }
2068
2069         cmd = ibmvscsis_get_free_cmd(vscsi);
2070         if (!cmd) {
2071                 dev_err(&vscsi->dev, "srp_cmd failed to get cmd, debit %d\n",
2072                         vscsi->debit);
2073                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2074                 return;
2075         }
2076         iue = cmd->iue;
2077         srp = &vio_iu(iue)->srp.cmd;
2078
2079         rc = ibmvscsis_copy_crq_packet(vscsi, cmd, crq);
2080         if (rc) {
2081                 ibmvscsis_free_cmd_resources(vscsi, cmd);
2082                 return;
2083         }
2084
2085         if (vscsi->state == SRP_PROCESSING) {
2086                 switch (srp->opcode) {
2087                 case SRP_LOGIN_REQ:
2088                         rc = ibmvscsis_srp_login(vscsi, cmd, crq);
2089                         break;
2090
2091                 case SRP_TSK_MGMT:
2092                         tsk = &vio_iu(iue)->srp.tsk_mgmt;
2093                         pr_debug("tsk_mgmt tag: %llu (0x%llx)\n", tsk->tag,
2094                                  tsk->tag);
2095                         cmd->rsp.tag = tsk->tag;
2096                         vscsi->debit += 1;
2097                         cmd->type = TASK_MANAGEMENT;
2098                         list_add_tail(&cmd->list, &vscsi->schedule_q);
2099                         queue_work(vscsi->work_q, &cmd->work);
2100                         break;
2101
2102                 case SRP_CMD:
2103                         pr_debug("srp_cmd tag: %llu (0x%llx)\n", srp->tag,
2104                                  srp->tag);
2105                         cmd->rsp.tag = srp->tag;
2106                         vscsi->debit += 1;
2107                         cmd->type = SCSI_CDB;
2108                         /*
2109                          * We want to keep track of work waiting for
2110                          * the workqueue.
2111                          */
2112                         list_add_tail(&cmd->list, &vscsi->schedule_q);
2113                         queue_work(vscsi->work_q, &cmd->work);
2114                         break;
2115
2116                 case SRP_I_LOGOUT:
2117                         rc = ibmvscsis_srp_i_logout(vscsi, cmd, crq);
2118                         break;
2119
2120                 case SRP_CRED_RSP:
2121                 case SRP_AER_RSP:
2122                 default:
2123                         ibmvscsis_free_cmd_resources(vscsi, cmd);
2124                         dev_err(&vscsi->dev, "invalid srp cmd, opcode %d\n",
2125                                 (uint)srp->opcode);
2126                         ibmvscsis_post_disconnect(vscsi,
2127                                                   ERR_DISCONNECT_RECONNECT, 0);
2128                         break;
2129                 }
2130         } else if (srp->opcode == SRP_LOGIN_REQ && vscsi->state == CONNECTED) {
2131                 rc = ibmvscsis_srp_login(vscsi, cmd, crq);
2132         } else {
2133                 ibmvscsis_free_cmd_resources(vscsi, cmd);
2134                 dev_err(&vscsi->dev, "Invalid state %d to handle srp cmd\n",
2135                         vscsi->state);
2136                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2137         }
2138 }
2139
2140 /**
2141  * ibmvscsis_ping_response() - Respond to a ping request
2142  * @vscsi:      Pointer to our adapter structure
2143  *
2144  * Let the client know that the server is alive and waiting on
2145  * its native I/O stack.
2146  * If any type of error occurs from the call to queue a ping
2147  * response then the client is either not accepting or receiving
2148  * interrupts.  Disconnect with an error.
2149  *
2150  * EXECUTION ENVIRONMENT:
2151  *      Interrupt, interrupt lock held
2152  */
2153 static long ibmvscsis_ping_response(struct scsi_info *vscsi)
2154 {
2155         struct viosrp_crq *crq;
2156         u64 buffer[2] = { 0, 0 };
2157         long rc;
2158
2159         crq = (struct viosrp_crq *)&buffer;
2160         crq->valid = VALID_CMD_RESP_EL;
2161         crq->format = (u8)MESSAGE_IN_CRQ;
2162         crq->status = PING_RESPONSE;
2163
2164         rc = h_send_crq(vscsi->dds.unit_id, cpu_to_be64(buffer[MSG_HI]),
2165                         cpu_to_be64(buffer[MSG_LOW]));
2166
2167         switch (rc) {
2168         case H_SUCCESS:
2169                 break;
2170         case H_CLOSED:
2171                 vscsi->flags |= CLIENT_FAILED;
2172         case H_DROPPED:
2173                 vscsi->flags |= RESPONSE_Q_DOWN;
2174         case H_REMOTE_PARM:
2175                 dev_err(&vscsi->dev, "ping_response: h_send_crq failed, rc %ld\n",
2176                         rc);
2177                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2178                 break;
2179         default:
2180                 dev_err(&vscsi->dev, "ping_response: h_send_crq returned unknown rc %ld\n",
2181                         rc);
2182                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0);
2183                 break;
2184         }
2185
2186         return rc;
2187 }
2188
2189 /**
2190  * ibmvscsis_handle_init_compl_msg() - Respond to an Init Complete Message
2191  * @vscsi:      Pointer to our adapter structure
2192  *
2193  * Must be called with interrupt lock held.
2194  */
2195 static long ibmvscsis_handle_init_compl_msg(struct scsi_info *vscsi)
2196 {
2197         long rc = ADAPT_SUCCESS;
2198
2199         switch (vscsi->state) {
2200         case NO_QUEUE:
2201         case ERR_DISCONNECT:
2202         case ERR_DISCONNECT_RECONNECT:
2203         case ERR_DISCONNECTED:
2204         case UNCONFIGURING:
2205         case UNDEFINED:
2206                 rc = ERROR;
2207                 break;
2208
2209         case WAIT_CONNECTION:
2210                 vscsi->state = CONNECTED;
2211                 break;
2212
2213         case WAIT_IDLE:
2214         case SRP_PROCESSING:
2215         case CONNECTED:
2216         case WAIT_ENABLED:
2217         case PART_UP_WAIT_ENAB:
2218         default:
2219                 rc = ERROR;
2220                 dev_err(&vscsi->dev, "init_msg: invalid state %d to get init compl msg\n",
2221                         vscsi->state);
2222                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2223                 break;
2224         }
2225
2226         return rc;
2227 }
2228
2229 /**
2230  * ibmvscsis_handle_init_msg() - Respond to an Init Message
2231  * @vscsi:      Pointer to our adapter structure
2232  *
2233  * Must be called with interrupt lock held.
2234  */
2235 static long ibmvscsis_handle_init_msg(struct scsi_info *vscsi)
2236 {
2237         long rc = ADAPT_SUCCESS;
2238
2239         switch (vscsi->state) {
2240         case WAIT_ENABLED:
2241                 vscsi->state = PART_UP_WAIT_ENAB;
2242                 break;
2243
2244         case WAIT_CONNECTION:
2245                 rc = ibmvscsis_send_init_message(vscsi, INIT_COMPLETE_MSG);
2246                 switch (rc) {
2247                 case H_SUCCESS:
2248                         vscsi->state = CONNECTED;
2249                         break;
2250
2251                 case H_PARAMETER:
2252                         dev_err(&vscsi->dev, "init_msg: failed to send, rc %ld\n",
2253                                 rc);
2254                         ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0);
2255                         break;
2256
2257                 case H_DROPPED:
2258                         dev_err(&vscsi->dev, "init_msg: failed to send, rc %ld\n",
2259                                 rc);
2260                         rc = ERROR;
2261                         ibmvscsis_post_disconnect(vscsi,
2262                                                   ERR_DISCONNECT_RECONNECT, 0);
2263                         break;
2264
2265                 case H_CLOSED:
2266                         pr_warn("init_msg: failed to send, rc %ld\n", rc);
2267                         rc = 0;
2268                         break;
2269                 }
2270                 break;
2271
2272         case UNDEFINED:
2273                 rc = ERROR;
2274                 break;
2275
2276         case UNCONFIGURING:
2277                 break;
2278
2279         case PART_UP_WAIT_ENAB:
2280         case CONNECTED:
2281         case SRP_PROCESSING:
2282         case WAIT_IDLE:
2283         case NO_QUEUE:
2284         case ERR_DISCONNECT:
2285         case ERR_DISCONNECT_RECONNECT:
2286         case ERR_DISCONNECTED:
2287         default:
2288                 rc = ERROR;
2289                 dev_err(&vscsi->dev, "init_msg: invalid state %d to get init msg\n",
2290                         vscsi->state);
2291                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2292                 break;
2293         }
2294
2295         return rc;
2296 }
2297
2298 /**
2299  * ibmvscsis_init_msg() - Respond to an init message
2300  * @vscsi:      Pointer to our adapter structure
2301  * @crq:        Pointer to CRQ element containing the Init Message
2302  *
2303  * EXECUTION ENVIRONMENT:
2304  *      Interrupt, interrupt lock held
2305  */
2306 static long ibmvscsis_init_msg(struct scsi_info *vscsi, struct viosrp_crq *crq)
2307 {
2308         long rc = ADAPT_SUCCESS;
2309
2310         pr_debug("init_msg: state 0x%hx\n", vscsi->state);
2311
2312         rc = h_vioctl(vscsi->dds.unit_id, H_GET_PARTNER_INFO,
2313                       (u64)vscsi->map_ioba | ((u64)PAGE_SIZE << 32), 0, 0, 0,
2314                       0);
2315         if (rc == H_SUCCESS) {
2316                 vscsi->client_data.partition_number =
2317                         be64_to_cpu(*(u64 *)vscsi->map_buf);
2318                 pr_debug("init_msg, part num %d\n",
2319                          vscsi->client_data.partition_number);
2320         } else {
2321                 pr_debug("init_msg h_vioctl rc %ld\n", rc);
2322                 rc = ADAPT_SUCCESS;
2323         }
2324
2325         if (crq->format == INIT_MSG) {
2326                 rc = ibmvscsis_handle_init_msg(vscsi);
2327         } else if (crq->format == INIT_COMPLETE_MSG) {
2328                 rc = ibmvscsis_handle_init_compl_msg(vscsi);
2329         } else {
2330                 rc = ERROR;
2331                 dev_err(&vscsi->dev, "init_msg: invalid format %d\n",
2332                         (uint)crq->format);
2333                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2334         }
2335
2336         return rc;
2337 }
2338
2339 /**
2340  * ibmvscsis_parse_command() - Parse an element taken from the cmd rsp queue.
2341  * @vscsi:      Pointer to our adapter structure
2342  * @crq:        Pointer to CRQ element containing the SRP request
2343  *
2344  * This function will return success if the command queue element is valid
2345  * and the srp iu or MAD request it pointed to was also valid.  That does
2346  * not mean that an error was not returned to the client.
2347  *
2348  * EXECUTION ENVIRONMENT:
2349  *      Interrupt, intr lock held
2350  */
2351 static long ibmvscsis_parse_command(struct scsi_info *vscsi,
2352                                     struct viosrp_crq *crq)
2353 {
2354         long rc = ADAPT_SUCCESS;
2355
2356         switch (crq->valid) {
2357         case VALID_CMD_RESP_EL:
2358                 switch (crq->format) {
2359                 case OS400_FORMAT:
2360                 case AIX_FORMAT:
2361                 case LINUX_FORMAT:
2362                 case MAD_FORMAT:
2363                         if (vscsi->flags & PROCESSING_MAD) {
2364                                 rc = ERROR;
2365                                 dev_err(&vscsi->dev, "parse_command: already processing mad\n");
2366                                 ibmvscsis_post_disconnect(vscsi,
2367                                                        ERR_DISCONNECT_RECONNECT,
2368                                                        0);
2369                         } else {
2370                                 vscsi->flags |= PROCESSING_MAD;
2371                                 rc = ibmvscsis_mad(vscsi, crq);
2372                         }
2373                         break;
2374
2375                 case SRP_FORMAT:
2376                         ibmvscsis_srp_cmd(vscsi, crq);
2377                         break;
2378
2379                 case MESSAGE_IN_CRQ:
2380                         if (crq->status == PING)
2381                                 ibmvscsis_ping_response(vscsi);
2382                         break;
2383
2384                 default:
2385                         dev_err(&vscsi->dev, "parse_command: invalid format %d\n",
2386                                 (uint)crq->format);
2387                         ibmvscsis_post_disconnect(vscsi,
2388                                                   ERR_DISCONNECT_RECONNECT, 0);
2389                         break;
2390                 }
2391                 break;
2392
2393         case VALID_TRANS_EVENT:
2394                 rc =  ibmvscsis_trans_event(vscsi, crq);
2395                 break;
2396
2397         case VALID_INIT_MSG:
2398                 rc = ibmvscsis_init_msg(vscsi, crq);
2399                 break;
2400
2401         default:
2402                 dev_err(&vscsi->dev, "parse_command: invalid valid field %d\n",
2403                         (uint)crq->valid);
2404                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2405                 break;
2406         }
2407
2408         /*
2409          * Return only what the interrupt handler cares
2410          * about. Most errors we keep right on trucking.
2411          */
2412         rc = vscsi->flags & SCHEDULE_DISCONNECT;
2413
2414         return rc;
2415 }
2416
2417 static int read_dma_window(struct scsi_info *vscsi)
2418 {
2419         struct vio_dev *vdev = vscsi->dma_dev;
2420         const __be32 *dma_window;
2421         const __be32 *prop;
2422
2423         /* TODO Using of_parse_dma_window would be better, but it doesn't give
2424          * a way to read multiple windows without already knowing the size of
2425          * a window or the number of windows.
2426          */
2427         dma_window = (const __be32 *)vio_get_attribute(vdev,
2428                                                        "ibm,my-dma-window",
2429                                                        NULL);
2430         if (!dma_window) {
2431                 pr_err("Couldn't find ibm,my-dma-window property\n");
2432                 return -1;
2433         }
2434
2435         vscsi->dds.window[LOCAL].liobn = be32_to_cpu(*dma_window);
2436         dma_window++;
2437
2438         prop = (const __be32 *)vio_get_attribute(vdev, "ibm,#dma-address-cells",
2439                                                  NULL);
2440         if (!prop) {
2441                 pr_warn("Couldn't find ibm,#dma-address-cells property\n");
2442                 dma_window++;
2443         } else {
2444                 dma_window += be32_to_cpu(*prop);
2445         }
2446
2447         prop = (const __be32 *)vio_get_attribute(vdev, "ibm,#dma-size-cells",
2448                                                  NULL);
2449         if (!prop) {
2450                 pr_warn("Couldn't find ibm,#dma-size-cells property\n");
2451                 dma_window++;
2452         } else {
2453                 dma_window += be32_to_cpu(*prop);
2454         }
2455
2456         /* dma_window should point to the second window now */
2457         vscsi->dds.window[REMOTE].liobn = be32_to_cpu(*dma_window);
2458
2459         return 0;
2460 }
2461
2462 static struct ibmvscsis_tport *ibmvscsis_lookup_port(const char *name)
2463 {
2464         struct ibmvscsis_tport *tport = NULL;
2465         struct vio_dev *vdev;
2466         struct scsi_info *vscsi;
2467
2468         spin_lock_bh(&ibmvscsis_dev_lock);
2469         list_for_each_entry(vscsi, &ibmvscsis_dev_list, list) {
2470                 vdev = vscsi->dma_dev;
2471                 if (!strcmp(dev_name(&vdev->dev), name)) {
2472                         tport = &vscsi->tport;
2473                         break;
2474                 }
2475         }
2476         spin_unlock_bh(&ibmvscsis_dev_lock);
2477
2478         return tport;
2479 }
2480
2481 /**
2482  * ibmvscsis_parse_cmd() - Parse SRP Command
2483  * @vscsi:      Pointer to our adapter structure
2484  * @cmd:        Pointer to command element with SRP command
2485  *
2486  * Parse the srp command; if it is valid then submit it to tcm.
2487  * Note: The return code does not reflect the status of the SCSI CDB.
2488  *
2489  * EXECUTION ENVIRONMENT:
2490  *      Process level
2491  */
2492 static void ibmvscsis_parse_cmd(struct scsi_info *vscsi,
2493                                 struct ibmvscsis_cmd *cmd)
2494 {
2495         struct iu_entry *iue = cmd->iue;
2496         struct srp_cmd *srp = (struct srp_cmd *)iue->sbuf->buf;
2497         struct ibmvscsis_nexus *nexus;
2498         u64 data_len = 0;
2499         enum dma_data_direction dir;
2500         int attr = 0;
2501         int rc = 0;
2502
2503         nexus = vscsi->tport.ibmv_nexus;
2504         /*
2505          * additional length in bytes.  Note that the SRP spec says that
2506          * additional length is in 4-byte words, but technically the
2507          * additional length field is only the upper 6 bits of the byte.
2508          * The lower 2 bits are reserved.  If the lower 2 bits are 0 (as
2509          * all reserved fields should be), then interpreting the byte as
2510          * an int will yield the length in bytes.
2511          */
2512         if (srp->add_cdb_len & 0x03) {
2513                 dev_err(&vscsi->dev, "parse_cmd: reserved bits set in IU\n");
2514                 spin_lock_bh(&vscsi->intr_lock);
2515                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2516                 ibmvscsis_free_cmd_resources(vscsi, cmd);
2517                 spin_unlock_bh(&vscsi->intr_lock);
2518                 return;
2519         }
2520
2521         if (srp_get_desc_table(srp, &dir, &data_len)) {
2522                 dev_err(&vscsi->dev, "0x%llx: parsing SRP descriptor table failed.\n",
2523                         srp->tag);
2524                 goto fail;
2525                 return;
2526         }
2527
2528         cmd->rsp.sol_not = srp->sol_not;
2529
2530         switch (srp->task_attr) {
2531         case SRP_SIMPLE_TASK:
2532                 attr = TCM_SIMPLE_TAG;
2533                 break;
2534         case SRP_ORDERED_TASK:
2535                 attr = TCM_ORDERED_TAG;
2536                 break;
2537         case SRP_HEAD_TASK:
2538                 attr = TCM_HEAD_TAG;
2539                 break;
2540         case SRP_ACA_TASK:
2541                 attr = TCM_ACA_TAG;
2542                 break;
2543         default:
2544                 dev_err(&vscsi->dev, "Invalid task attribute %d\n",
2545                         srp->task_attr);
2546                 goto fail;
2547         }
2548
2549         cmd->se_cmd.tag = be64_to_cpu(srp->tag);
2550
2551         spin_lock_bh(&vscsi->intr_lock);
2552         list_add_tail(&cmd->list, &vscsi->active_q);
2553         spin_unlock_bh(&vscsi->intr_lock);
2554
2555         srp->lun.scsi_lun[0] &= 0x3f;
2556
2557         rc = target_submit_cmd(&cmd->se_cmd, nexus->se_sess, srp->cdb,
2558                                cmd->sense_buf, scsilun_to_int(&srp->lun),
2559                                data_len, attr, dir, 0);
2560         if (rc) {
2561                 dev_err(&vscsi->dev, "target_submit_cmd failed, rc %d\n", rc);
2562                 goto fail;
2563         }
2564         return;
2565
2566 fail:
2567         spin_lock_bh(&vscsi->intr_lock);
2568         ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2569         spin_unlock_bh(&vscsi->intr_lock);
2570 }
2571
2572 /**
2573  * ibmvscsis_parse_task() - Parse SRP Task Management Request
2574  * @vscsi:      Pointer to our adapter structure
2575  * @cmd:        Pointer to command element with SRP task management request
2576  *
2577  * Parse the srp task management request; if it is valid then submit it to tcm.
2578  * Note: The return code does not reflect the status of the task management
2579  * request.
2580  *
2581  * EXECUTION ENVIRONMENT:
2582  *      Processor level
2583  */
2584 static void ibmvscsis_parse_task(struct scsi_info *vscsi,
2585                                  struct ibmvscsis_cmd *cmd)
2586 {
2587         struct iu_entry *iue = cmd->iue;
2588         struct srp_tsk_mgmt *srp_tsk = &vio_iu(iue)->srp.tsk_mgmt;
2589         int tcm_type;
2590         u64 tag_to_abort = 0;
2591         int rc = 0;
2592         struct ibmvscsis_nexus *nexus;
2593
2594         nexus = vscsi->tport.ibmv_nexus;
2595
2596         cmd->rsp.sol_not = srp_tsk->sol_not;
2597
2598         switch (srp_tsk->tsk_mgmt_func) {
2599         case SRP_TSK_ABORT_TASK:
2600                 tcm_type = TMR_ABORT_TASK;
2601                 tag_to_abort = be64_to_cpu(srp_tsk->task_tag);
2602                 break;
2603         case SRP_TSK_ABORT_TASK_SET:
2604                 tcm_type = TMR_ABORT_TASK_SET;
2605                 break;
2606         case SRP_TSK_CLEAR_TASK_SET:
2607                 tcm_type = TMR_CLEAR_TASK_SET;
2608                 break;
2609         case SRP_TSK_LUN_RESET:
2610                 tcm_type = TMR_LUN_RESET;
2611                 break;
2612         case SRP_TSK_CLEAR_ACA:
2613                 tcm_type = TMR_CLEAR_ACA;
2614                 break;
2615         default:
2616                 dev_err(&vscsi->dev, "unknown task mgmt func %d\n",
2617                         srp_tsk->tsk_mgmt_func);
2618                 cmd->se_cmd.se_tmr_req->response =
2619                         TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED;
2620                 rc = -1;
2621                 break;
2622         }
2623
2624         if (!rc) {
2625                 cmd->se_cmd.tag = be64_to_cpu(srp_tsk->tag);
2626
2627                 spin_lock_bh(&vscsi->intr_lock);
2628                 list_add_tail(&cmd->list, &vscsi->active_q);
2629                 spin_unlock_bh(&vscsi->intr_lock);
2630
2631                 srp_tsk->lun.scsi_lun[0] &= 0x3f;
2632
2633                 pr_debug("calling submit_tmr, func %d\n",
2634                          srp_tsk->tsk_mgmt_func);
2635                 rc = target_submit_tmr(&cmd->se_cmd, nexus->se_sess, NULL,
2636                                        scsilun_to_int(&srp_tsk->lun), srp_tsk,
2637                                        tcm_type, GFP_KERNEL, tag_to_abort, 0);
2638                 if (rc) {
2639                         dev_err(&vscsi->dev, "target_submit_tmr failed, rc %d\n",
2640                                 rc);
2641                         cmd->se_cmd.se_tmr_req->response =
2642                                 TMR_FUNCTION_REJECTED;
2643                 }
2644         }
2645
2646         if (rc)
2647                 transport_send_check_condition_and_sense(&cmd->se_cmd, 0, 0);
2648 }
2649
2650 static void ibmvscsis_scheduler(struct work_struct *work)
2651 {
2652         struct ibmvscsis_cmd *cmd = container_of(work, struct ibmvscsis_cmd,
2653                                                  work);
2654         struct scsi_info *vscsi = cmd->adapter;
2655
2656         spin_lock_bh(&vscsi->intr_lock);
2657
2658         /* Remove from schedule_q */
2659         list_del(&cmd->list);
2660
2661         /* Don't submit cmd if we're disconnecting */
2662         if (vscsi->flags & (SCHEDULE_DISCONNECT | DISCONNECT_SCHEDULED)) {
2663                 ibmvscsis_free_cmd_resources(vscsi, cmd);
2664
2665                 /* ibmvscsis_disconnect might be waiting for us */
2666                 if (list_empty(&vscsi->active_q) &&
2667                     list_empty(&vscsi->schedule_q) &&
2668                     (vscsi->flags & WAIT_FOR_IDLE)) {
2669                         vscsi->flags &= ~WAIT_FOR_IDLE;
2670                         complete(&vscsi->wait_idle);
2671                 }
2672
2673                 spin_unlock_bh(&vscsi->intr_lock);
2674                 return;
2675         }
2676
2677         spin_unlock_bh(&vscsi->intr_lock);
2678
2679         switch (cmd->type) {
2680         case SCSI_CDB:
2681                 ibmvscsis_parse_cmd(vscsi, cmd);
2682                 break;
2683         case TASK_MANAGEMENT:
2684                 ibmvscsis_parse_task(vscsi, cmd);
2685                 break;
2686         default:
2687                 dev_err(&vscsi->dev, "scheduler, invalid cmd type %d\n",
2688                         cmd->type);
2689                 spin_lock_bh(&vscsi->intr_lock);
2690                 ibmvscsis_free_cmd_resources(vscsi, cmd);
2691                 spin_unlock_bh(&vscsi->intr_lock);
2692                 break;
2693         }
2694 }
2695
2696 static int ibmvscsis_alloc_cmds(struct scsi_info *vscsi, int num)
2697 {
2698         struct ibmvscsis_cmd *cmd;
2699         int i;
2700
2701         INIT_LIST_HEAD(&vscsi->free_cmd);
2702         vscsi->cmd_pool = kcalloc(num, sizeof(struct ibmvscsis_cmd),
2703                                   GFP_KERNEL);
2704         if (!vscsi->cmd_pool)
2705                 return -ENOMEM;
2706
2707         for (i = 0, cmd = (struct ibmvscsis_cmd *)vscsi->cmd_pool; i < num;
2708              i++, cmd++) {
2709                 cmd->adapter = vscsi;
2710                 INIT_WORK(&cmd->work, ibmvscsis_scheduler);
2711                 list_add_tail(&cmd->list, &vscsi->free_cmd);
2712         }
2713
2714         return 0;
2715 }
2716
2717 static void ibmvscsis_free_cmds(struct scsi_info *vscsi)
2718 {
2719         kfree(vscsi->cmd_pool);
2720         vscsi->cmd_pool = NULL;
2721         INIT_LIST_HEAD(&vscsi->free_cmd);
2722 }
2723
2724 /**
2725  * ibmvscsis_service_wait_q() - Service Waiting Queue
2726  * @timer:      Pointer to timer which has expired
2727  *
2728  * This routine is called when the timer pops to service the waiting
2729  * queue. Elements on the queue have completed, their responses have been
2730  * copied to the client, but the client's response queue was full so
2731  * the queue message could not be sent. The routine grabs the proper locks
2732  * and calls send messages.
2733  *
2734  * EXECUTION ENVIRONMENT:
2735  *      called at interrupt level
2736  */
2737 static enum hrtimer_restart ibmvscsis_service_wait_q(struct hrtimer *timer)
2738 {
2739         struct timer_cb *p_timer = container_of(timer, struct timer_cb, timer);
2740         struct scsi_info *vscsi = container_of(p_timer, struct scsi_info,
2741                                                rsp_q_timer);
2742
2743         spin_lock_bh(&vscsi->intr_lock);
2744         p_timer->timer_pops += 1;
2745         p_timer->started = false;
2746         ibmvscsis_send_messages(vscsi);
2747         spin_unlock_bh(&vscsi->intr_lock);
2748
2749         return HRTIMER_NORESTART;
2750 }
2751
2752 static long ibmvscsis_alloctimer(struct scsi_info *vscsi)
2753 {
2754         struct timer_cb *p_timer;
2755
2756         p_timer = &vscsi->rsp_q_timer;
2757         hrtimer_init(&p_timer->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
2758
2759         p_timer->timer.function = ibmvscsis_service_wait_q;
2760         p_timer->started = false;
2761         p_timer->timer_pops = 0;
2762
2763         return ADAPT_SUCCESS;
2764 }
2765
2766 static void ibmvscsis_freetimer(struct scsi_info *vscsi)
2767 {
2768         struct timer_cb *p_timer;
2769
2770         p_timer = &vscsi->rsp_q_timer;
2771
2772         (void)hrtimer_cancel(&p_timer->timer);
2773
2774         p_timer->started = false;
2775         p_timer->timer_pops = 0;
2776 }
2777
2778 static irqreturn_t ibmvscsis_interrupt(int dummy, void *data)
2779 {
2780         struct scsi_info *vscsi = data;
2781
2782         vio_disable_interrupts(vscsi->dma_dev);
2783         tasklet_schedule(&vscsi->work_task);
2784
2785         return IRQ_HANDLED;
2786 }
2787
2788 /**
2789  * ibmvscsis_check_q() - Helper function to Check Init Message Valid
2790  * @vscsi:      Pointer to our adapter structure
2791  *
2792  * Checks if a initialize message was queued by the initiatior
2793  * while the timing window was open.  This function is called from
2794  * probe after the CRQ is created and interrupts are enabled.
2795  * It would only be used by adapters who wait for some event before
2796  * completing the init handshake with the client.  For ibmvscsi, this
2797  * event is waiting for the port to be enabled.
2798  *
2799  * EXECUTION ENVIRONMENT:
2800  *      Process level only, interrupt lock held
2801  */
2802 static long ibmvscsis_check_q(struct scsi_info *vscsi)
2803 {
2804         uint format;
2805         long rc;
2806
2807         rc = ibmvscsis_check_init_msg(vscsi, &format);
2808         if (rc)
2809                 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0);
2810         else if (format == UNUSED_FORMAT)
2811                 vscsi->state = WAIT_ENABLED;
2812         else
2813                 vscsi->state = PART_UP_WAIT_ENAB;
2814
2815         return rc;
2816 }
2817
2818 /**
2819  * ibmvscsis_enable_change_state() - Set new state based on enabled status
2820  * @vscsi:      Pointer to our adapter structure
2821  *
2822  * This function determines our new state now that we are enabled.  This
2823  * may involve sending an Init Complete message to the client.
2824  *
2825  * Must be called with interrupt lock held.
2826  */
2827 static long ibmvscsis_enable_change_state(struct scsi_info *vscsi)
2828 {
2829         long rc = ADAPT_SUCCESS;
2830
2831 handle_state_change:
2832         switch (vscsi->state) {
2833         case WAIT_ENABLED:
2834                 rc = ibmvscsis_send_init_message(vscsi, INIT_MSG);
2835                 switch (rc) {
2836                 case H_SUCCESS:
2837                 case H_DROPPED:
2838                 case H_CLOSED:
2839                         vscsi->state =  WAIT_CONNECTION;
2840                         rc = ADAPT_SUCCESS;
2841                         break;
2842
2843                 case H_PARAMETER:
2844                         break;
2845
2846                 case H_HARDWARE:
2847                         break;
2848
2849                 default:
2850                         vscsi->state = UNDEFINED;
2851                         rc = H_HARDWARE;
2852                         break;
2853                 }
2854                 break;
2855         case PART_UP_WAIT_ENAB:
2856                 rc = ibmvscsis_send_init_message(vscsi, INIT_COMPLETE_MSG);
2857                 switch (rc) {
2858                 case H_SUCCESS:
2859                         vscsi->state = CONNECTED;
2860                         rc = ADAPT_SUCCESS;
2861                         break;
2862
2863                 case H_DROPPED:
2864                 case H_CLOSED:
2865                         vscsi->state = WAIT_ENABLED;
2866                         goto handle_state_change;
2867
2868                 case H_PARAMETER:
2869                         break;
2870
2871                 case H_HARDWARE:
2872                         break;
2873
2874                 default:
2875                         rc = H_HARDWARE;
2876                         break;
2877                 }
2878                 break;
2879
2880         case WAIT_CONNECTION:
2881         case WAIT_IDLE:
2882         case SRP_PROCESSING:
2883         case CONNECTED:
2884                 rc = ADAPT_SUCCESS;
2885                 break;
2886                 /* should not be able to get here */
2887         case UNCONFIGURING:
2888                 rc = ERROR;
2889                 vscsi->state = UNDEFINED;
2890                 break;
2891
2892                 /* driver should never allow this to happen */
2893         case ERR_DISCONNECT:
2894         case ERR_DISCONNECT_RECONNECT:
2895         default:
2896                 dev_err(&vscsi->dev, "in invalid state %d during enable_change_state\n",
2897                         vscsi->state);
2898                 rc = ADAPT_SUCCESS;
2899                 break;
2900         }
2901
2902         return rc;
2903 }
2904
2905 /**
2906  * ibmvscsis_create_command_q() - Create Command Queue
2907  * @vscsi:      Pointer to our adapter structure
2908  * @num_cmds:   Currently unused.  In the future, may be used to determine
2909  *              the size of the CRQ.
2910  *
2911  * Allocates memory for command queue maps remote memory into an ioba
2912  * initializes the command response queue
2913  *
2914  * EXECUTION ENVIRONMENT:
2915  *      Process level only
2916  */
2917 static long ibmvscsis_create_command_q(struct scsi_info *vscsi, int num_cmds)
2918 {
2919         long rc = 0;
2920         int pages;
2921         struct vio_dev *vdev = vscsi->dma_dev;
2922
2923         /* We might support multiple pages in the future, but just 1 for now */
2924         pages = 1;
2925
2926         vscsi->cmd_q.size = pages;
2927
2928         vscsi->cmd_q.base_addr =
2929                 (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL);
2930         if (!vscsi->cmd_q.base_addr)
2931                 return -ENOMEM;
2932
2933         vscsi->cmd_q.mask = ((uint)pages * CRQ_PER_PAGE) - 1;
2934
2935         vscsi->cmd_q.crq_token = dma_map_single(&vdev->dev,
2936                                                 vscsi->cmd_q.base_addr,
2937                                                 PAGE_SIZE, DMA_BIDIRECTIONAL);
2938         if (dma_mapping_error(&vdev->dev, vscsi->cmd_q.crq_token)) {
2939                 free_page((unsigned long)vscsi->cmd_q.base_addr);
2940                 return -ENOMEM;
2941         }
2942
2943         rc =  h_reg_crq(vscsi->dds.unit_id, vscsi->cmd_q.crq_token, PAGE_SIZE);
2944         if (rc) {
2945                 if (rc == H_CLOSED) {
2946                         vscsi->state = WAIT_ENABLED;
2947                         rc = 0;
2948                 } else {
2949                         dma_unmap_single(&vdev->dev, vscsi->cmd_q.crq_token,
2950                                          PAGE_SIZE, DMA_BIDIRECTIONAL);
2951                         free_page((unsigned long)vscsi->cmd_q.base_addr);
2952                         rc = -ENODEV;
2953                 }
2954         } else {
2955                 vscsi->state = WAIT_ENABLED;
2956         }
2957
2958         return rc;
2959 }
2960
2961 /**
2962  * ibmvscsis_destroy_command_q - Destroy Command Queue
2963  * @vscsi:      Pointer to our adapter structure
2964  *
2965  * Releases memory for command queue and unmaps mapped remote memory.
2966  *
2967  * EXECUTION ENVIRONMENT:
2968  *      Process level only
2969  */
2970 static void ibmvscsis_destroy_command_q(struct scsi_info *vscsi)
2971 {
2972         dma_unmap_single(&vscsi->dma_dev->dev, vscsi->cmd_q.crq_token,
2973                          PAGE_SIZE, DMA_BIDIRECTIONAL);
2974         free_page((unsigned long)vscsi->cmd_q.base_addr);
2975         vscsi->cmd_q.base_addr = NULL;
2976         vscsi->state = NO_QUEUE;
2977 }
2978
2979 static u8 ibmvscsis_fast_fail(struct scsi_info *vscsi,
2980                               struct ibmvscsis_cmd *cmd)
2981 {
2982         struct iu_entry *iue = cmd->iue;
2983         struct se_cmd *se_cmd = &cmd->se_cmd;
2984         struct srp_cmd *srp = (struct srp_cmd *)iue->sbuf->buf;
2985         struct scsi_sense_hdr sshdr;
2986         u8 rc = se_cmd->scsi_status;
2987
2988         if (vscsi->fast_fail && (READ_CMD(srp->cdb) || WRITE_CMD(srp->cdb)))
2989                 if (scsi_normalize_sense(se_cmd->sense_buffer,
2990                                          se_cmd->scsi_sense_length, &sshdr))
2991                         if (sshdr.sense_key == HARDWARE_ERROR &&
2992                             (se_cmd->residual_count == 0 ||
2993                              se_cmd->residual_count == se_cmd->data_length)) {
2994                                 rc = NO_SENSE;
2995                                 cmd->flags |= CMD_FAST_FAIL;
2996                         }
2997
2998         return rc;
2999 }
3000
3001 /**
3002  * srp_build_response() - Build an SRP response buffer
3003  * @vscsi:      Pointer to our adapter structure
3004  * @cmd:        Pointer to command for which to send the response
3005  * @len_p:      Where to return the length of the IU response sent.  This
3006  *              is needed to construct the CRQ response.
3007  *
3008  * Build the SRP response buffer and copy it to the client's memory space.
3009  */
3010 static long srp_build_response(struct scsi_info *vscsi,
3011                                struct ibmvscsis_cmd *cmd, uint *len_p)
3012 {
3013         struct iu_entry *iue = cmd->iue;
3014         struct se_cmd *se_cmd = &cmd->se_cmd;
3015         struct srp_rsp *rsp;
3016         uint len;
3017         u32 rsp_code;
3018         char *data;
3019         u32 *tsk_status;
3020         long rc = ADAPT_SUCCESS;
3021
3022         spin_lock_bh(&vscsi->intr_lock);
3023
3024         rsp = &vio_iu(iue)->srp.rsp;
3025         len = sizeof(*rsp);
3026         memset(rsp, 0, len);
3027         data = rsp->data;
3028
3029         rsp->opcode = SRP_RSP;
3030
3031         if (vscsi->credit > 0 && vscsi->state == SRP_PROCESSING)
3032                 rsp->req_lim_delta = cpu_to_be32(vscsi->credit);
3033         else
3034                 rsp->req_lim_delta = cpu_to_be32(1 + vscsi->credit);
3035         rsp->tag = cmd->rsp.tag;
3036         rsp->flags = 0;
3037
3038         if (cmd->type == SCSI_CDB) {
3039                 rsp->status = ibmvscsis_fast_fail(vscsi, cmd);
3040                 if (rsp->status) {
3041                         pr_debug("build_resp: cmd %p, scsi status %d\n", cmd,
3042                                  (int)rsp->status);
3043                         ibmvscsis_determine_resid(se_cmd, rsp);
3044                         if (se_cmd->scsi_sense_length && se_cmd->sense_buffer) {
3045                                 rsp->sense_data_len =
3046                                         cpu_to_be32(se_cmd->scsi_sense_length);
3047                                 rsp->flags |= SRP_RSP_FLAG_SNSVALID;
3048                                 len += se_cmd->scsi_sense_length;
3049                                 memcpy(data, se_cmd->sense_buffer,
3050                                        se_cmd->scsi_sense_length);
3051                         }
3052                         rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >>
3053                                 UCSOLNT_RESP_SHIFT;
3054                 } else if (cmd->flags & CMD_FAST_FAIL) {
3055                         pr_debug("build_resp: cmd %p, fast fail\n", cmd);
3056                         rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >>
3057                                 UCSOLNT_RESP_SHIFT;
3058                 } else {
3059                         rsp->sol_not = (cmd->rsp.sol_not & SCSOLNT) >>
3060                                 SCSOLNT_RESP_SHIFT;
3061                 }
3062         } else {
3063                 /* this is task management */
3064                 rsp->status = 0;
3065                 rsp->resp_data_len = cpu_to_be32(4);
3066                 rsp->flags |= SRP_RSP_FLAG_RSPVALID;
3067
3068                 switch (se_cmd->se_tmr_req->response) {
3069                 case TMR_FUNCTION_COMPLETE:
3070                 case TMR_TASK_DOES_NOT_EXIST:
3071                         rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_COMPLETE;
3072                         rsp->sol_not = (cmd->rsp.sol_not & SCSOLNT) >>
3073                                 SCSOLNT_RESP_SHIFT;
3074                         break;
3075                 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED:
3076                 case TMR_LUN_DOES_NOT_EXIST:
3077                         rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_NOT_SUPPORTED;
3078                         rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >>
3079                                 UCSOLNT_RESP_SHIFT;
3080                         break;
3081                 case TMR_FUNCTION_FAILED:
3082                 case TMR_FUNCTION_REJECTED:
3083                 default:
3084                         rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_FAILED;
3085                         rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >>
3086                                 UCSOLNT_RESP_SHIFT;
3087                         break;
3088                 }
3089
3090                 tsk_status = (u32 *)data;
3091                 *tsk_status = cpu_to_be32(rsp_code);
3092                 data = (char *)(tsk_status + 1);
3093                 len += 4;
3094         }
3095
3096         dma_wmb();
3097         rc = h_copy_rdma(len, vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma,
3098                          vscsi->dds.window[REMOTE].liobn,
3099                          be64_to_cpu(iue->remote_token));
3100
3101         switch (rc) {
3102         case H_SUCCESS:
3103                 vscsi->credit = 0;
3104                 *len_p = len;
3105                 break;
3106         case H_PERMISSION:
3107                 if (connection_broken(vscsi))
3108                         vscsi->flags |= RESPONSE_Q_DOWN | CLIENT_FAILED;
3109
3110                 dev_err(&vscsi->dev, "build_response: error copying to client, rc %ld, flags 0x%x, state 0x%hx\n",
3111                         rc, vscsi->flags, vscsi->state);
3112                 break;
3113         case H_SOURCE_PARM:
3114         case H_DEST_PARM:
3115         default:
3116                 dev_err(&vscsi->dev, "build_response: error copying to client, rc %ld\n",
3117                         rc);
3118                 break;
3119         }
3120
3121         spin_unlock_bh(&vscsi->intr_lock);
3122
3123         return rc;
3124 }
3125
3126 static int ibmvscsis_rdma(struct ibmvscsis_cmd *cmd, struct scatterlist *sg,
3127                           int nsg, struct srp_direct_buf *md, int nmd,
3128                           enum dma_data_direction dir, unsigned int bytes)
3129 {
3130         struct iu_entry *iue = cmd->iue;
3131         struct srp_target *target = iue->target;
3132         struct scsi_info *vscsi = target->ldata;
3133         struct scatterlist *sgp;
3134         dma_addr_t client_ioba, server_ioba;
3135         ulong buf_len;
3136         ulong client_len, server_len;
3137         int md_idx;
3138         long tx_len;
3139         long rc = 0;
3140
3141         if (bytes == 0)
3142                 return 0;
3143
3144         sgp = sg;
3145         client_len = 0;
3146         server_len = 0;
3147         md_idx = 0;
3148         tx_len = bytes;
3149
3150         do {
3151                 if (client_len == 0) {
3152                         if (md_idx >= nmd) {
3153                                 dev_err(&vscsi->dev, "rdma: ran out of client memory descriptors\n");
3154                                 rc = -EIO;
3155                                 break;
3156                         }
3157                         client_ioba = be64_to_cpu(md[md_idx].va);
3158                         client_len = be32_to_cpu(md[md_idx].len);
3159                 }
3160                 if (server_len == 0) {
3161                         if (!sgp) {
3162                                 dev_err(&vscsi->dev, "rdma: ran out of scatter/gather list\n");
3163                                 rc = -EIO;
3164                                 break;
3165                         }
3166                         server_ioba = sg_dma_address(sgp);
3167                         server_len = sg_dma_len(sgp);
3168                 }
3169
3170                 buf_len = tx_len;
3171
3172                 if (buf_len > client_len)
3173                         buf_len = client_len;
3174
3175                 if (buf_len > server_len)
3176                         buf_len = server_len;
3177
3178                 if (buf_len > max_vdma_size)
3179                         buf_len = max_vdma_size;
3180
3181                 if (dir == DMA_TO_DEVICE) {
3182                         /* read from client */
3183                         rc = h_copy_rdma(buf_len,
3184                                          vscsi->dds.window[REMOTE].liobn,
3185                                          client_ioba,
3186                                          vscsi->dds.window[LOCAL].liobn,
3187                                          server_ioba);
3188                 } else {
3189                         /* The h_copy_rdma will cause phyp, running in another
3190                          * partition, to read memory, so we need to make sure
3191                          * the data has been written out, hence these syncs.
3192                          */
3193                         /* ensure that everything is in memory */
3194                         isync();
3195                         /* ensure that memory has been made visible */
3196                         dma_wmb();
3197                         rc = h_copy_rdma(buf_len,
3198                                          vscsi->dds.window[LOCAL].liobn,
3199                                          server_ioba,
3200                                          vscsi->dds.window[REMOTE].liobn,
3201                                          client_ioba);
3202                 }
3203                 switch (rc) {
3204                 case H_SUCCESS:
3205                         break;
3206                 case H_PERMISSION:
3207                 case H_SOURCE_PARM:
3208                 case H_DEST_PARM:
3209                         if (connection_broken(vscsi)) {
3210                                 spin_lock_bh(&vscsi->intr_lock);
3211                                 vscsi->flags |=
3212                                         (RESPONSE_Q_DOWN | CLIENT_FAILED);
3213                                 spin_unlock_bh(&vscsi->intr_lock);
3214                         }
3215                         dev_err(&vscsi->dev, "rdma: h_copy_rdma failed, rc %ld\n",
3216                                 rc);
3217                         break;
3218
3219                 default:
3220                         dev_err(&vscsi->dev, "rdma: unknown error %ld from h_copy_rdma\n",
3221                                 rc);
3222                         break;
3223                 }
3224
3225                 if (!rc) {
3226                         tx_len -= buf_len;
3227                         if (tx_len) {
3228                                 client_len -= buf_len;
3229                                 if (client_len == 0)
3230                                         md_idx++;
3231                                 else
3232                                         client_ioba += buf_len;
3233
3234                                 server_len -= buf_len;
3235                                 if (server_len == 0)
3236                                         sgp = sg_next(sgp);
3237                                 else
3238                                         server_ioba += buf_len;
3239                         } else {
3240                                 break;
3241                         }
3242                 }
3243         } while (!rc);
3244
3245         return rc;
3246 }
3247
3248 /**
3249  * ibmvscsis_handle_crq() - Handle CRQ
3250  * @data:       Pointer to our adapter structure
3251  *
3252  * Read the command elements from the command queue and copy the payloads
3253  * associated with the command elements to local memory and execute the
3254  * SRP requests.
3255  *
3256  * Note: this is an edge triggered interrupt. It can not be shared.
3257  */
3258 static void ibmvscsis_handle_crq(unsigned long data)
3259 {
3260         struct scsi_info *vscsi = (struct scsi_info *)data;
3261         struct viosrp_crq *crq;
3262         long rc;
3263         bool ack = true;
3264         volatile u8 valid;
3265
3266         spin_lock_bh(&vscsi->intr_lock);
3267
3268         pr_debug("got interrupt\n");
3269
3270         /*
3271          * if we are in a path where we are waiting for all pending commands
3272          * to complete because we received a transport event and anything in
3273          * the command queue is for a new connection,  do nothing
3274          */
3275         if (TARGET_STOP(vscsi)) {
3276                 vio_enable_interrupts(vscsi->dma_dev);
3277
3278                 pr_debug("handle_crq, don't process: flags 0x%x, state 0x%hx\n",
3279                          vscsi->flags, vscsi->state);
3280                 spin_unlock_bh(&vscsi->intr_lock);
3281                 return;
3282         }
3283
3284         rc = vscsi->flags & SCHEDULE_DISCONNECT;
3285         crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index;
3286         valid = crq->valid;
3287         dma_rmb();
3288
3289         while (valid) {
3290                 /*
3291                  * These are edege triggered interrupts. After dropping out of
3292                  * the while loop, the code must check for work since an
3293                  * interrupt could be lost, and an elment be left on the queue,
3294                  * hence the label.
3295                  */
3296 cmd_work:
3297                 vscsi->cmd_q.index =
3298                         (vscsi->cmd_q.index + 1) & vscsi->cmd_q.mask;
3299
3300                 if (!rc) {
3301                         rc = ibmvscsis_parse_command(vscsi, crq);
3302                 } else {
3303                         if ((uint)crq->valid == VALID_TRANS_EVENT) {
3304                                 /*
3305                                  * must service the transport layer events even
3306                                  * in an error state, dont break out until all
3307                                  * the consecutive transport events have been
3308                                  * processed
3309                                  */
3310                                 rc = ibmvscsis_trans_event(vscsi, crq);
3311                         } else if (vscsi->flags & TRANS_EVENT) {
3312                                 /*
3313                                  * if a transport event has occurred leave
3314                                  * everything but transport events on the queue
3315                                  *
3316                                  * need to decrement the queue index so we can
3317                                  * look at the elment again
3318                                  */
3319                                 if (vscsi->cmd_q.index)
3320                                         vscsi->cmd_q.index -= 1;
3321                                 else
3322                                         /*
3323                                          * index is at 0 it just wrapped.
3324                                          * have it index last element in q
3325                                          */
3326                                         vscsi->cmd_q.index = vscsi->cmd_q.mask;
3327                                 break;
3328                         }
3329                 }
3330
3331                 crq->valid = INVALIDATE_CMD_RESP_EL;
3332
3333                 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index;
3334                 valid = crq->valid;
3335                 dma_rmb();
3336         }
3337
3338         if (!rc) {
3339                 if (ack) {
3340                         vio_enable_interrupts(vscsi->dma_dev);
3341                         ack = false;
3342                         pr_debug("handle_crq, reenabling interrupts\n");
3343                 }
3344                 valid = crq->valid;
3345                 dma_rmb();
3346                 if (valid)
3347                         goto cmd_work;
3348         } else {
3349                 pr_debug("handle_crq, error: flags 0x%x, state 0x%hx, crq index 0x%x\n",
3350                          vscsi->flags, vscsi->state, vscsi->cmd_q.index);
3351         }
3352
3353         pr_debug("Leaving handle_crq: schedule_q empty %d, flags 0x%x, state 0x%hx\n",
3354                  (int)list_empty(&vscsi->schedule_q), vscsi->flags,
3355                  vscsi->state);
3356
3357         spin_unlock_bh(&vscsi->intr_lock);
3358 }
3359
3360 static int ibmvscsis_probe(struct vio_dev *vdev,
3361                            const struct vio_device_id *id)
3362 {
3363         struct scsi_info *vscsi;
3364         int rc = 0;
3365         long hrc = 0;
3366         char wq_name[24];
3367
3368         vscsi = kzalloc(sizeof(*vscsi), GFP_KERNEL);
3369         if (!vscsi) {
3370                 rc = -ENOMEM;
3371                 pr_err("probe: allocation of adapter failed\n");
3372                 return rc;
3373         }
3374
3375         vscsi->dma_dev = vdev;
3376         vscsi->dev = vdev->dev;
3377         INIT_LIST_HEAD(&vscsi->schedule_q);
3378         INIT_LIST_HEAD(&vscsi->waiting_rsp);
3379         INIT_LIST_HEAD(&vscsi->active_q);
3380
3381         snprintf(vscsi->tport.tport_name, 256, "%s", dev_name(&vdev->dev));
3382
3383         pr_debug("probe tport_name: %s\n", vscsi->tport.tport_name);
3384
3385         rc = read_dma_window(vscsi);
3386         if (rc)
3387                 goto free_adapter;
3388         pr_debug("Probe: liobn 0x%x, riobn 0x%x\n",
3389                  vscsi->dds.window[LOCAL].liobn,
3390                  vscsi->dds.window[REMOTE].liobn);
3391
3392         strcpy(vscsi->eye, "VSCSI ");
3393         strncat(vscsi->eye, vdev->name, MAX_EYE);
3394
3395         vscsi->dds.unit_id = vdev->unit_address;
3396
3397         spin_lock_bh(&ibmvscsis_dev_lock);
3398         list_add_tail(&vscsi->list, &ibmvscsis_dev_list);
3399         spin_unlock_bh(&ibmvscsis_dev_lock);
3400
3401         /*
3402          * TBD: How do we determine # of cmds to request?  Do we know how
3403          * many "children" we have?
3404          */
3405         vscsi->request_limit = INITIAL_SRP_LIMIT;
3406         rc = srp_target_alloc(&vscsi->target, &vdev->dev, vscsi->request_limit,
3407                               SRP_MAX_IU_LEN);
3408         if (rc)
3409                 goto rem_list;
3410
3411         vscsi->target.ldata = vscsi;
3412
3413         rc = ibmvscsis_alloc_cmds(vscsi, vscsi->request_limit);
3414         if (rc) {
3415                 dev_err(&vscsi->dev, "alloc_cmds failed, rc %d, num %d\n",
3416                         rc, vscsi->request_limit);
3417                 goto free_target;
3418         }
3419
3420         /*
3421          * Note: the lock is used in freeing timers, so must initialize
3422          * first so that ordering in case of error is correct.
3423          */
3424         spin_lock_init(&vscsi->intr_lock);
3425
3426         rc = ibmvscsis_alloctimer(vscsi);
3427         if (rc) {
3428                 dev_err(&vscsi->dev, "probe: alloctimer failed, rc %d\n", rc);
3429                 goto free_cmds;
3430         }
3431
3432         rc = ibmvscsis_create_command_q(vscsi, 256);
3433         if (rc) {
3434                 dev_err(&vscsi->dev, "probe: create_command_q failed, rc %d\n",
3435                         rc);
3436                 goto free_timer;
3437         }
3438
3439         vscsi->map_buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
3440         if (!vscsi->map_buf) {
3441                 rc = -ENOMEM;
3442                 dev_err(&vscsi->dev, "probe: allocating cmd buffer failed\n");
3443                 goto destroy_queue;
3444         }
3445
3446         vscsi->map_ioba = dma_map_single(&vdev->dev, vscsi->map_buf, PAGE_SIZE,
3447                                          DMA_BIDIRECTIONAL);
3448         if (dma_mapping_error(&vdev->dev, vscsi->map_ioba)) {
3449                 rc = -ENOMEM;
3450                 dev_err(&vscsi->dev, "probe: error mapping command buffer\n");
3451                 goto free_buf;
3452         }
3453
3454         hrc = h_vioctl(vscsi->dds.unit_id, H_GET_PARTNER_INFO,
3455                        (u64)vscsi->map_ioba | ((u64)PAGE_SIZE << 32), 0, 0, 0,
3456                        0);
3457         if (hrc == H_SUCCESS)
3458                 vscsi->client_data.partition_number =
3459                         be64_to_cpu(*(u64 *)vscsi->map_buf);
3460         /*
3461          * We expect the VIOCTL to fail if we're configured as "any
3462          * client can connect" and the client isn't activated yet.
3463          * We'll make the call again when he sends an init msg.
3464          */
3465         pr_debug("probe hrc %ld, client partition num %d\n",
3466                  hrc, vscsi->client_data.partition_number);
3467
3468         tasklet_init(&vscsi->work_task, ibmvscsis_handle_crq,
3469                      (unsigned long)vscsi);
3470
3471         init_completion(&vscsi->wait_idle);
3472
3473         snprintf(wq_name, 24, "ibmvscsis%s", dev_name(&vdev->dev));
3474         vscsi->work_q = create_workqueue(wq_name);
3475         if (!vscsi->work_q) {
3476                 rc = -ENOMEM;
3477                 dev_err(&vscsi->dev, "create_workqueue failed\n");
3478                 goto unmap_buf;
3479         }
3480
3481         rc = request_irq(vdev->irq, ibmvscsis_interrupt, 0, "ibmvscsis", vscsi);
3482         if (rc) {
3483                 rc = -EPERM;
3484                 dev_err(&vscsi->dev, "probe: request_irq failed, rc %d\n", rc);
3485                 goto destroy_WQ;
3486         }
3487
3488         spin_lock_bh(&vscsi->intr_lock);
3489         vio_enable_interrupts(vdev);
3490         if (rc) {
3491                 dev_err(&vscsi->dev, "enabling interrupts failed, rc %d\n", rc);
3492                 rc = -ENODEV;
3493                 spin_unlock_bh(&vscsi->intr_lock);
3494                 goto free_irq;
3495         }
3496
3497         if (ibmvscsis_check_q(vscsi)) {
3498                 rc = ERROR;
3499                 dev_err(&vscsi->dev, "probe: check_q failed, rc %d\n", rc);
3500                 spin_unlock_bh(&vscsi->intr_lock);
3501                 goto disable_interrupt;
3502         }
3503         spin_unlock_bh(&vscsi->intr_lock);
3504
3505         dev_set_drvdata(&vdev->dev, vscsi);
3506
3507         return 0;
3508
3509 disable_interrupt:
3510         vio_disable_interrupts(vdev);
3511 free_irq:
3512         free_irq(vdev->irq, vscsi);
3513 destroy_WQ:
3514         destroy_workqueue(vscsi->work_q);
3515 unmap_buf:
3516         dma_unmap_single(&vdev->dev, vscsi->map_ioba, PAGE_SIZE,
3517                          DMA_BIDIRECTIONAL);
3518 free_buf:
3519         kfree(vscsi->map_buf);
3520 destroy_queue:
3521         tasklet_kill(&vscsi->work_task);
3522         ibmvscsis_unregister_command_q(vscsi);
3523         ibmvscsis_destroy_command_q(vscsi);
3524 free_timer:
3525         ibmvscsis_freetimer(vscsi);
3526 free_cmds:
3527         ibmvscsis_free_cmds(vscsi);
3528 free_target:
3529         srp_target_free(&vscsi->target);
3530 rem_list:
3531         spin_lock_bh(&ibmvscsis_dev_lock);
3532         list_del(&vscsi->list);
3533         spin_unlock_bh(&ibmvscsis_dev_lock);
3534 free_adapter:
3535         kfree(vscsi);
3536
3537         return rc;
3538 }
3539
3540 static int ibmvscsis_remove(struct vio_dev *vdev)
3541 {
3542         struct scsi_info *vscsi = dev_get_drvdata(&vdev->dev);
3543
3544         pr_debug("remove (%s)\n", dev_name(&vscsi->dma_dev->dev));
3545
3546         /*
3547          * TBD: Need to handle if there are commands on the waiting_rsp q
3548          *      Actually, can there still be cmds outstanding to tcm?
3549          */
3550
3551         vio_disable_interrupts(vdev);
3552         free_irq(vdev->irq, vscsi);
3553         destroy_workqueue(vscsi->work_q);
3554         dma_unmap_single(&vdev->dev, vscsi->map_ioba, PAGE_SIZE,
3555                          DMA_BIDIRECTIONAL);
3556         kfree(vscsi->map_buf);
3557         tasklet_kill(&vscsi->work_task);
3558         ibmvscsis_unregister_command_q(vscsi);
3559         ibmvscsis_destroy_command_q(vscsi);
3560         ibmvscsis_freetimer(vscsi);
3561         ibmvscsis_free_cmds(vscsi);
3562         srp_target_free(&vscsi->target);
3563         spin_lock_bh(&ibmvscsis_dev_lock);
3564         list_del(&vscsi->list);
3565         spin_unlock_bh(&ibmvscsis_dev_lock);
3566         kfree(vscsi);
3567
3568         return 0;
3569 }
3570
3571 static ssize_t system_id_show(struct device *dev,
3572                               struct device_attribute *attr, char *buf)
3573 {
3574         return snprintf(buf, PAGE_SIZE, "%s\n", system_id);
3575 }
3576
3577 static ssize_t partition_number_show(struct device *dev,
3578                                      struct device_attribute *attr, char *buf)
3579 {
3580         return snprintf(buf, PAGE_SIZE, "%x\n", partition_number);
3581 }
3582
3583 static ssize_t unit_address_show(struct device *dev,
3584                                  struct device_attribute *attr, char *buf)
3585 {
3586         struct scsi_info *vscsi = container_of(dev, struct scsi_info, dev);
3587
3588         return snprintf(buf, PAGE_SIZE, "%x\n", vscsi->dma_dev->unit_address);
3589 }
3590
3591 static int ibmvscsis_get_system_info(void)
3592 {
3593         struct device_node *rootdn, *vdevdn;
3594         const char *id, *model, *name;
3595         const uint *num;
3596
3597         rootdn = of_find_node_by_path("/");
3598         if (!rootdn)
3599                 return -ENOENT;
3600
3601         model = of_get_property(rootdn, "model", NULL);
3602         id = of_get_property(rootdn, "system-id", NULL);
3603         if (model && id)
3604                 snprintf(system_id, sizeof(system_id), "%s-%s", model, id);
3605
3606         name = of_get_property(rootdn, "ibm,partition-name", NULL);
3607         if (name)
3608                 strncpy(partition_name, name, sizeof(partition_name));
3609
3610         num = of_get_property(rootdn, "ibm,partition-no", NULL);
3611         if (num)
3612                 partition_number = *num;
3613
3614         of_node_put(rootdn);
3615
3616         vdevdn = of_find_node_by_path("/vdevice");
3617         if (vdevdn) {
3618                 const uint *mvds;
3619
3620                 mvds = of_get_property(vdevdn, "ibm,max-virtual-dma-size",
3621                                        NULL);
3622                 if (mvds)
3623                         max_vdma_size = *mvds;
3624                 of_node_put(vdevdn);
3625         }
3626
3627         return 0;
3628 }
3629
3630 static char *ibmvscsis_get_fabric_name(void)
3631 {
3632         return "ibmvscsis";
3633 }
3634
3635 static char *ibmvscsis_get_fabric_wwn(struct se_portal_group *se_tpg)
3636 {
3637         struct ibmvscsis_tport *tport =
3638                 container_of(se_tpg, struct ibmvscsis_tport, se_tpg);
3639
3640         return tport->tport_name;
3641 }
3642
3643 static u16 ibmvscsis_get_tag(struct se_portal_group *se_tpg)
3644 {
3645         struct ibmvscsis_tport *tport =
3646                 container_of(se_tpg, struct ibmvscsis_tport, se_tpg);
3647
3648         return tport->tport_tpgt;
3649 }
3650
3651 static u32 ibmvscsis_get_default_depth(struct se_portal_group *se_tpg)
3652 {
3653         return 1;
3654 }
3655
3656 static int ibmvscsis_check_true(struct se_portal_group *se_tpg)
3657 {
3658         return 1;
3659 }
3660
3661 static int ibmvscsis_check_false(struct se_portal_group *se_tpg)
3662 {
3663         return 0;
3664 }
3665
3666 static u32 ibmvscsis_tpg_get_inst_index(struct se_portal_group *se_tpg)
3667 {
3668         return 1;
3669 }
3670
3671 static int ibmvscsis_check_stop_free(struct se_cmd *se_cmd)
3672 {
3673         return target_put_sess_cmd(se_cmd);
3674 }
3675
3676 static void ibmvscsis_release_cmd(struct se_cmd *se_cmd)
3677 {
3678         struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,
3679                                                  se_cmd);
3680         struct scsi_info *vscsi = cmd->adapter;
3681
3682         spin_lock_bh(&vscsi->intr_lock);
3683         /* Remove from active_q */
3684         list_move_tail(&cmd->list, &vscsi->waiting_rsp);
3685         ibmvscsis_send_messages(vscsi);
3686         spin_unlock_bh(&vscsi->intr_lock);
3687 }
3688
3689 static u32 ibmvscsis_sess_get_index(struct se_session *se_sess)
3690 {
3691         return 0;
3692 }
3693
3694 static int ibmvscsis_write_pending(struct se_cmd *se_cmd)
3695 {
3696         struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,
3697                                                  se_cmd);
3698         struct iu_entry *iue = cmd->iue;
3699         int rc;
3700
3701         rc = srp_transfer_data(cmd, &vio_iu(iue)->srp.cmd, ibmvscsis_rdma,
3702                                1, 1);
3703         if (rc) {
3704                 pr_err("srp_transfer_data() failed: %d\n", rc);
3705                 return -EAGAIN;
3706         }
3707         /*
3708          * We now tell TCM to add this WRITE CDB directly into the TCM storage
3709          * object execution queue.
3710          */
3711         target_execute_cmd(se_cmd);
3712         return 0;
3713 }
3714
3715 static int ibmvscsis_write_pending_status(struct se_cmd *se_cmd)
3716 {
3717         return 0;
3718 }
3719
3720 static void ibmvscsis_set_default_node_attrs(struct se_node_acl *nacl)
3721 {
3722 }
3723
3724 static int ibmvscsis_get_cmd_state(struct se_cmd *se_cmd)
3725 {
3726         return 0;
3727 }
3728
3729 static int ibmvscsis_queue_data_in(struct se_cmd *se_cmd)
3730 {
3731         struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,
3732                                                  se_cmd);
3733         struct iu_entry *iue = cmd->iue;
3734         struct scsi_info *vscsi = cmd->adapter;
3735         char *sd;
3736         uint len = 0;
3737         int rc;
3738
3739         rc = srp_transfer_data(cmd, &vio_iu(iue)->srp.cmd, ibmvscsis_rdma, 1,
3740                                1);
3741         if (rc) {
3742                 pr_err("srp_transfer_data failed: %d\n", rc);
3743                 sd = se_cmd->sense_buffer;
3744                 se_cmd->scsi_sense_length = 18;
3745                 memset(se_cmd->sense_buffer, 0, se_cmd->scsi_sense_length);
3746                 /* Logical Unit Communication Time-out asc/ascq = 0x0801 */
3747                 scsi_build_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
3748                                         0x08, 0x01);
3749         }
3750
3751         srp_build_response(vscsi, cmd, &len);
3752         cmd->rsp.format = SRP_FORMAT;
3753         cmd->rsp.len = len;
3754
3755         return 0;
3756 }
3757
3758 static int ibmvscsis_queue_status(struct se_cmd *se_cmd)
3759 {
3760         struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,
3761                                                  se_cmd);
3762         struct scsi_info *vscsi = cmd->adapter;
3763         uint len;
3764
3765         pr_debug("queue_status %p\n", se_cmd);
3766
3767         srp_build_response(vscsi, cmd, &len);
3768         cmd->rsp.format = SRP_FORMAT;
3769         cmd->rsp.len = len;
3770
3771         return 0;
3772 }
3773
3774 static void ibmvscsis_queue_tm_rsp(struct se_cmd *se_cmd)
3775 {
3776         struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,
3777                                                  se_cmd);
3778         struct scsi_info *vscsi = cmd->adapter;
3779         uint len;
3780
3781         pr_debug("queue_tm_rsp %p, status %d\n",
3782                  se_cmd, (int)se_cmd->se_tmr_req->response);
3783
3784         srp_build_response(vscsi, cmd, &len);
3785         cmd->rsp.format = SRP_FORMAT;
3786         cmd->rsp.len = len;
3787 }
3788
3789 static void ibmvscsis_aborted_task(struct se_cmd *se_cmd)
3790 {
3791         /* TBD: What (if anything) should we do here? */
3792         pr_debug("ibmvscsis_aborted_task %p\n", se_cmd);
3793 }
3794
3795 static struct se_wwn *ibmvscsis_make_tport(struct target_fabric_configfs *tf,
3796                                            struct config_group *group,
3797                                            const char *name)
3798 {
3799         struct ibmvscsis_tport *tport;
3800
3801         tport = ibmvscsis_lookup_port(name);
3802         if (tport) {
3803                 tport->tport_proto_id = SCSI_PROTOCOL_SRP;
3804                 pr_debug("make_tport(%s), pointer:%p, tport_id:%x\n",
3805                          name, tport, tport->tport_proto_id);
3806                 return &tport->tport_wwn;
3807         }
3808
3809         return ERR_PTR(-EINVAL);
3810 }
3811
3812 static void ibmvscsis_drop_tport(struct se_wwn *wwn)
3813 {
3814         struct ibmvscsis_tport *tport = container_of(wwn,
3815                                                      struct ibmvscsis_tport,
3816                                                      tport_wwn);
3817
3818         pr_debug("drop_tport(%s)\n",
3819                  config_item_name(&tport->tport_wwn.wwn_group.cg_item));
3820 }
3821
3822 static struct se_portal_group *ibmvscsis_make_tpg(struct se_wwn *wwn,
3823                                                   struct config_group *group,
3824                                                   const char *name)
3825 {
3826         struct ibmvscsis_tport *tport =
3827                 container_of(wwn, struct ibmvscsis_tport, tport_wwn);
3828         int rc;
3829
3830         tport->releasing = false;
3831
3832         rc = core_tpg_register(&tport->tport_wwn, &tport->se_tpg,
3833                                tport->tport_proto_id);
3834         if (rc)
3835                 return ERR_PTR(rc);
3836
3837         return &tport->se_tpg;
3838 }
3839
3840 static void ibmvscsis_drop_tpg(struct se_portal_group *se_tpg)
3841 {
3842         struct ibmvscsis_tport *tport = container_of(se_tpg,
3843                                                      struct ibmvscsis_tport,
3844                                                      se_tpg);
3845
3846         tport->releasing = true;
3847         tport->enabled = false;
3848
3849         /*
3850          * Release the virtual I_T Nexus for this ibmvscsis TPG
3851          */
3852         ibmvscsis_drop_nexus(tport);
3853         /*
3854          * Deregister the se_tpg from TCM..
3855          */
3856         core_tpg_deregister(se_tpg);
3857 }
3858
3859 static ssize_t ibmvscsis_wwn_version_show(struct config_item *item,
3860                                           char *page)
3861 {
3862         return scnprintf(page, PAGE_SIZE, "%s\n", IBMVSCSIS_VERSION);
3863 }
3864 CONFIGFS_ATTR_RO(ibmvscsis_wwn_, version);
3865
3866 static struct configfs_attribute *ibmvscsis_wwn_attrs[] = {
3867         &ibmvscsis_wwn_attr_version,
3868         NULL,
3869 };
3870
3871 static ssize_t ibmvscsis_tpg_enable_show(struct config_item *item,
3872                                          char *page)
3873 {
3874         struct se_portal_group *se_tpg = to_tpg(item);
3875         struct ibmvscsis_tport *tport = container_of(se_tpg,
3876                                                      struct ibmvscsis_tport,
3877                                                      se_tpg);
3878
3879         return snprintf(page, PAGE_SIZE, "%d\n", (tport->enabled) ? 1 : 0);
3880 }
3881
3882 static ssize_t ibmvscsis_tpg_enable_store(struct config_item *item,
3883                                           const char *page, size_t count)
3884 {
3885         struct se_portal_group *se_tpg = to_tpg(item);
3886         struct ibmvscsis_tport *tport = container_of(se_tpg,
3887                                                      struct ibmvscsis_tport,
3888                                                      se_tpg);
3889         struct scsi_info *vscsi = container_of(tport, struct scsi_info, tport);
3890         unsigned long tmp;
3891         int rc;
3892         long lrc;
3893
3894         rc = kstrtoul(page, 0, &tmp);
3895         if (rc < 0) {
3896                 pr_err("Unable to extract srpt_tpg_store_enable\n");
3897                 return -EINVAL;
3898         }
3899
3900         if ((tmp != 0) && (tmp != 1)) {
3901                 pr_err("Illegal value for srpt_tpg_store_enable\n");
3902                 return -EINVAL;
3903         }
3904
3905         if (tmp) {
3906                 tport->enabled = true;
3907                 spin_lock_bh(&vscsi->intr_lock);
3908                 lrc = ibmvscsis_enable_change_state(vscsi);
3909                 if (lrc)
3910                         pr_err("enable_change_state failed, rc %ld state %d\n",
3911                                lrc, vscsi->state);
3912                 spin_unlock_bh(&vscsi->intr_lock);
3913         } else {
3914                 tport->enabled = false;
3915         }
3916
3917         pr_debug("tpg_enable_store, state %d\n", vscsi->state);
3918
3919         return count;
3920 }
3921 CONFIGFS_ATTR(ibmvscsis_tpg_, enable);
3922
3923 static struct configfs_attribute *ibmvscsis_tpg_attrs[] = {
3924         &ibmvscsis_tpg_attr_enable,
3925         NULL,
3926 };
3927
3928 static const struct target_core_fabric_ops ibmvscsis_ops = {
3929         .module                         = THIS_MODULE,
3930         .name                           = "ibmvscsis",
3931         .get_fabric_name                = ibmvscsis_get_fabric_name,
3932         .tpg_get_wwn                    = ibmvscsis_get_fabric_wwn,
3933         .tpg_get_tag                    = ibmvscsis_get_tag,
3934         .tpg_get_default_depth          = ibmvscsis_get_default_depth,
3935         .tpg_check_demo_mode            = ibmvscsis_check_true,
3936         .tpg_check_demo_mode_cache      = ibmvscsis_check_true,
3937         .tpg_check_demo_mode_write_protect = ibmvscsis_check_false,
3938         .tpg_check_prod_mode_write_protect = ibmvscsis_check_false,
3939         .tpg_get_inst_index             = ibmvscsis_tpg_get_inst_index,
3940         .check_stop_free                = ibmvscsis_check_stop_free,
3941         .release_cmd                    = ibmvscsis_release_cmd,
3942         .sess_get_index                 = ibmvscsis_sess_get_index,
3943         .write_pending                  = ibmvscsis_write_pending,
3944         .write_pending_status           = ibmvscsis_write_pending_status,
3945         .set_default_node_attributes    = ibmvscsis_set_default_node_attrs,
3946         .get_cmd_state                  = ibmvscsis_get_cmd_state,
3947         .queue_data_in                  = ibmvscsis_queue_data_in,
3948         .queue_status                   = ibmvscsis_queue_status,
3949         .queue_tm_rsp                   = ibmvscsis_queue_tm_rsp,
3950         .aborted_task                   = ibmvscsis_aborted_task,
3951         /*
3952          * Setup function pointers for logic in target_core_fabric_configfs.c
3953          */
3954         .fabric_make_wwn                = ibmvscsis_make_tport,
3955         .fabric_drop_wwn                = ibmvscsis_drop_tport,
3956         .fabric_make_tpg                = ibmvscsis_make_tpg,
3957         .fabric_drop_tpg                = ibmvscsis_drop_tpg,
3958
3959         .tfc_wwn_attrs                  = ibmvscsis_wwn_attrs,
3960         .tfc_tpg_base_attrs             = ibmvscsis_tpg_attrs,
3961 };
3962
3963 static void ibmvscsis_dev_release(struct device *dev) {};
3964
3965 static struct class_attribute ibmvscsis_class_attrs[] = {
3966         __ATTR_NULL,
3967 };
3968
3969 static struct device_attribute dev_attr_system_id =
3970         __ATTR(system_id, S_IRUGO, system_id_show, NULL);
3971
3972 static struct device_attribute dev_attr_partition_number =
3973         __ATTR(partition_number, S_IRUGO, partition_number_show, NULL);
3974
3975 static struct device_attribute dev_attr_unit_address =
3976         __ATTR(unit_address, S_IRUGO, unit_address_show, NULL);
3977
3978 static struct attribute *ibmvscsis_dev_attrs[] = {
3979         &dev_attr_system_id.attr,
3980         &dev_attr_partition_number.attr,
3981         &dev_attr_unit_address.attr,
3982 };
3983 ATTRIBUTE_GROUPS(ibmvscsis_dev);
3984
3985 static struct class ibmvscsis_class = {
3986         .name           = "ibmvscsis",
3987         .dev_release    = ibmvscsis_dev_release,
3988         .class_attrs    = ibmvscsis_class_attrs,
3989         .dev_groups     = ibmvscsis_dev_groups,
3990 };
3991
3992 static struct vio_device_id ibmvscsis_device_table[] = {
3993         { "v-scsi-host", "IBM,v-scsi-host" },
3994         { "", "" }
3995 };
3996 MODULE_DEVICE_TABLE(vio, ibmvscsis_device_table);
3997
3998 static struct vio_driver ibmvscsis_driver = {
3999         .name = "ibmvscsis",
4000         .id_table = ibmvscsis_device_table,
4001         .probe = ibmvscsis_probe,
4002         .remove = ibmvscsis_remove,
4003 };
4004
4005 /*
4006  * ibmvscsis_init() - Kernel Module initialization
4007  *
4008  * Note: vio_register_driver() registers callback functions, and at least one
4009  * of those callback functions calls TCM - Linux IO Target Subsystem, thus
4010  * the SCSI Target template must be registered before vio_register_driver()
4011  * is called.
4012  */
4013 static int __init ibmvscsis_init(void)
4014 {
4015         int rc = 0;
4016
4017         rc = ibmvscsis_get_system_info();
4018         if (rc) {
4019                 pr_err("rc %d from get_system_info\n", rc);
4020                 goto out;
4021         }
4022
4023         rc = class_register(&ibmvscsis_class);
4024         if (rc) {
4025                 pr_err("failed class register\n");
4026                 goto out;
4027         }
4028
4029         rc = target_register_template(&ibmvscsis_ops);
4030         if (rc) {
4031                 pr_err("rc %d from target_register_template\n", rc);
4032                 goto unregister_class;
4033         }
4034
4035         rc = vio_register_driver(&ibmvscsis_driver);
4036         if (rc) {
4037                 pr_err("rc %d from vio_register_driver\n", rc);
4038                 goto unregister_target;
4039         }
4040
4041         return 0;
4042
4043 unregister_target:
4044         target_unregister_template(&ibmvscsis_ops);
4045 unregister_class:
4046         class_unregister(&ibmvscsis_class);
4047 out:
4048         return rc;
4049 }
4050
4051 static void __exit ibmvscsis_exit(void)
4052 {
4053         pr_info("Unregister IBM virtual SCSI host driver\n");
4054         vio_unregister_driver(&ibmvscsis_driver);
4055         target_unregister_template(&ibmvscsis_ops);
4056         class_unregister(&ibmvscsis_class);
4057 }
4058
4059 MODULE_DESCRIPTION("IBMVSCSIS fabric driver");
4060 MODULE_AUTHOR("Bryant G. Ly and Michael Cyr");
4061 MODULE_LICENSE("GPL");
4062 MODULE_VERSION(IBMVSCSIS_VERSION);
4063 module_init(ibmvscsis_init);
4064 module_exit(ibmvscsis_exit);