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