drivers/scsi/ibmvscsi/ibmvscsi.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* ------------------------------------------------------------
   3  * ibmvscsi.c
   4  * (C) Copyright IBM Corporation 1994, 2004
   5  * Authors: Colin DeVilbiss (devilbis@us.ibm.com)
   6  *          Santiago Leon (santil@us.ibm.com)
   7  *          Dave Boutcher (sleddog@us.ibm.com)
   8  *
   9  * ------------------------------------------------------------
  10  * Emulation of a SCSI host adapter for Virtual I/O devices
  11  *
  12  * This driver supports the SCSI adapter implemented by the IBM
  13  * Power5 firmware.  That SCSI adapter is not a physical adapter,
  14  * but allows Linux SCSI peripheral drivers to directly
  15  * access devices in another logical partition on the physical system.
  16  *
  17  * The virtual adapter(s) are present in the open firmware device
  18  * tree just like real adapters.
  19  *
  20  * One of the capabilities provided on these systems is the ability
  21  * to DMA between partitions.  The architecture states that for VSCSI,
  22  * the server side is allowed to DMA to and from the client.  The client
  23  * is never trusted to DMA to or from the server directly.
  24  *
  25  * Messages are sent between partitions on a "Command/Response Queue"
  26  * (CRQ), which is just a buffer of 16 byte entries in the receiver's
  27  * Senders cannot access the buffer directly, but send messages by
  28  * making a hypervisor call and passing in the 16 bytes.  The hypervisor
  29  * puts the message in the next 16 byte space in round-robin fashion,
  30  * turns on the high order bit of the message (the valid bit), and
  31  * generates an interrupt to the receiver (if interrupts are turned on.)
  32  * The receiver just turns off the valid bit when they have copied out
  33  * the message.
  34  *
  35  * The VSCSI client builds a SCSI Remote Protocol (SRP) Information Unit
  36  * (IU) (as defined in the T10 standard available at www.t10.org), gets
  37  * a DMA address for the message, and sends it to the server as the
  38  * payload of a CRQ message.  The server DMAs the SRP IU and processes it,
  39  * including doing any additional data transfers.  When it is done, it
  40  * DMAs the SRP response back to the same address as the request came from,
  41  * and sends a CRQ message back to inform the client that the request has
  42  * completed.
  43  *
  44  * TODO: This is currently pretty tied to the IBM pSeries hypervisor
  45  * interfaces.  It would be really nice to abstract this above an RDMA
  46  * layer.
  47  */
  48
  49 #include <linux/module.h>
  50 #include <linux/moduleparam.h>
  51 #include <linux/dma-mapping.h>
  52 #include <linux/delay.h>
  53 #include <linux/slab.h>
  54 #include <linux/of.h>
  55 #include <linux/pm.h>
  56 #include <linux/kthread.h>
  57 #include <asm/firmware.h>
  58 #include <asm/vio.h>
  59 #include <scsi/scsi.h>
  60 #include <scsi/scsi_cmnd.h>
  61 #include <scsi/scsi_host.h>
  62 #include <scsi/scsi_device.h>
  63 #include <scsi/scsi_transport_srp.h>
  64 #include "ibmvscsi.h"
  65
  66 /* The values below are somewhat arbitrary default values, but
  67  * OS/400 will use 3 busses (disks, CDs, tapes, I think.)
  68  * Note that there are 3 bits of channel value, 6 bits of id, and
  69  * 5 bits of LUN.
  70  */
  71 static int max_id = 64;
  72 static int max_channel = 3;
  73 static int init_timeout = 300;
  74 static int login_timeout = 60;
  75 static int info_timeout = 30;
  76 static int abort_timeout = 60;
  77 static int reset_timeout = 60;
  78 static int max_requests = IBMVSCSI_MAX_REQUESTS_DEFAULT;
  79 static int max_events = IBMVSCSI_MAX_REQUESTS_DEFAULT + 2;
  80 static int fast_fail = 1;
  81 static int client_reserve = 1;
  82 static char partition_name[96] = "UNKNOWN";
  83 static unsigned int partition_number = -1;
  84 static LIST_HEAD(ibmvscsi_head);
  85 static DEFINE_SPINLOCK(ibmvscsi_driver_lock);
  86
  87 static struct scsi_transport_template *ibmvscsi_transport_template;
  88
  89 #define IBMVSCSI_VERSION "1.5.9"
  90
  91 MODULE_DESCRIPTION("IBM Virtual SCSI");
  92 MODULE_AUTHOR("Dave Boutcher");
  93 MODULE_LICENSE("GPL");
  94 MODULE_VERSION(IBMVSCSI_VERSION);
  95
  96 module_param_named(max_id, max_id, int, S_IRUGO | S_IWUSR);
  97 MODULE_PARM_DESC(max_id, "Largest ID value for each channel [Default=64]");
  98 module_param_named(max_channel, max_channel, int, S_IRUGO | S_IWUSR);
  99 MODULE_PARM_DESC(max_channel, "Largest channel value [Default=3]");
 100 module_param_named(init_timeout, init_timeout, int, S_IRUGO | S_IWUSR);
 101 MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds");
 102 module_param_named(max_requests, max_requests, int, S_IRUGO);
 103 MODULE_PARM_DESC(max_requests, "Maximum requests for this adapter");
 104 module_param_named(fast_fail, fast_fail, int, S_IRUGO | S_IWUSR);
 105 MODULE_PARM_DESC(fast_fail, "Enable fast fail. [Default=1]");
 106 module_param_named(client_reserve, client_reserve, int, S_IRUGO );
 107 MODULE_PARM_DESC(client_reserve, "Attempt client managed reserve/release");
 108
 109 static void ibmvscsi_handle_crq(struct viosrp_crq *crq,
 110                                 struct ibmvscsi_host_data *hostdata);
 111
 112 /* ------------------------------------------------------------
 113  * Routines for managing the command/response queue
 114  */
 115 /**
 116  * ibmvscsi_handle_event: - Interrupt handler for crq events
 117  * @irq:        number of irq to handle, not used
 118  * @dev_instance: ibmvscsi_host_data of host that received interrupt
 119  *
 120  * Disables interrupts and schedules srp_task
 121  * Always returns IRQ_HANDLED
 122  */
 123 static irqreturn_t ibmvscsi_handle_event(int irq, void *dev_instance)
 124 {
 125         struct ibmvscsi_host_data *hostdata =
 126             (struct ibmvscsi_host_data *)dev_instance;
 127         vio_disable_interrupts(to_vio_dev(hostdata->dev));
 128         tasklet_schedule(&hostdata->srp_task);
 129         return IRQ_HANDLED;
 130 }
 131
 132 /**
 133  * ibmvscsi_release_crq_queue() - Deallocates data and unregisters CRQ
 134  * @queue:              crq_queue to initialize and register
 135  * @hostdata:           ibmvscsi_host_data of host
 136  * @max_requests:       maximum requests (unused)
 137  *
 138  * Frees irq, deallocates a page for messages, unmaps dma, and unregisters
 139  * the crq with the hypervisor.
 140  */
 141 static void ibmvscsi_release_crq_queue(struct crq_queue *queue,
 142                                        struct ibmvscsi_host_data *hostdata,
 143                                        int max_requests)
 144 {
 145         long rc = 0;
 146         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 147         free_irq(vdev->irq, (void *)hostdata);
 148         tasklet_kill(&hostdata->srp_task);
 149         do {
 150                 if (rc)
 151                         msleep(100);
 152                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
 153         } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
 154         dma_unmap_single(hostdata->dev,
 155                          queue->msg_token,
 156                          queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
 157         free_page((unsigned long)queue->msgs);
 158 }
 159
 160 /**
 161  * crq_queue_next_crq: - Returns the next entry in message queue
 162  * @queue:      crq_queue to use
 163  *
 164  * Returns pointer to next entry in queue, or NULL if there are no new
 165  * entried in the CRQ.
 166  */
 167 static struct viosrp_crq *crq_queue_next_crq(struct crq_queue *queue)
 168 {
 169         struct viosrp_crq *crq;
 170         unsigned long flags;
 171
 172         spin_lock_irqsave(&queue->lock, flags);
 173         crq = &queue->msgs[queue->cur];
 174         if (crq->valid != VIOSRP_CRQ_FREE) {
 175                 if (++queue->cur == queue->size)
 176                         queue->cur = 0;
 177
 178                 /* Ensure the read of the valid bit occurs before reading any
 179                  * other bits of the CRQ entry
 180                  */
 181                 rmb();
 182         } else
 183                 crq = NULL;
 184         spin_unlock_irqrestore(&queue->lock, flags);
 185
 186         return crq;
 187 }
 188
 189 /**
 190  * ibmvscsi_send_crq: - Send a CRQ
 191  * @hostdata:   the adapter
 192  * @word1:      the first 64 bits of the data
 193  * @word2:      the second 64 bits of the data
 194  */
 195 static int ibmvscsi_send_crq(struct ibmvscsi_host_data *hostdata,
 196                              u64 word1, u64 word2)
 197 {
 198         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 199
 200         /*
 201          * Ensure the command buffer is flushed to memory before handing it
 202          * over to the VIOS to prevent it from fetching any stale data.
 203          */
 204         mb();
 205         return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
 206 }
 207
 208 /**
 209  * ibmvscsi_task: - Process srps asynchronously
 210  * @data:       ibmvscsi_host_data of host
 211  */
 212 static void ibmvscsi_task(void *data)
 213 {
 214         struct ibmvscsi_host_data *hostdata = (struct ibmvscsi_host_data *)data;
 215         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 216         struct viosrp_crq *crq;
 217         int done = 0;
 218
 219         while (!done) {
 220                 /* Pull all the valid messages off the CRQ */
 221                 while ((crq = crq_queue_next_crq(&hostdata->queue)) != NULL) {
 222                         ibmvscsi_handle_crq(crq, hostdata);
 223                         crq->valid = VIOSRP_CRQ_FREE;
 224                         wmb();
 225                 }
 226
 227                 vio_enable_interrupts(vdev);
 228                 crq = crq_queue_next_crq(&hostdata->queue);
 229                 if (crq != NULL) {
 230                         vio_disable_interrupts(vdev);
 231                         ibmvscsi_handle_crq(crq, hostdata);
 232                         crq->valid = VIOSRP_CRQ_FREE;
 233                         wmb();
 234                 } else {
 235                         done = 1;
 236                 }
 237         }
 238 }
 239
 240 static void gather_partition_info(void)
 241 {
 242         const char *ppartition_name;
 243         const __be32 *p_number_ptr;
 244
 245         /* Retrieve information about this partition */
 246         if (!of_root)
 247                 return;
 248
 249         of_node_get(of_root);
 250
 251         ppartition_name = of_get_property(of_root, "ibm,partition-name", NULL);
 252         if (ppartition_name)
 253                 strscpy(partition_name, ppartition_name,
 254                                 sizeof(partition_name));
 255         p_number_ptr = of_get_property(of_root, "ibm,partition-no", NULL);
 256         if (p_number_ptr)
 257                 partition_number = of_read_number(p_number_ptr, 1);
 258         of_node_put(of_root);
 259 }
 260
 261 static void set_adapter_info(struct ibmvscsi_host_data *hostdata)
 262 {
 263         memset(&hostdata->madapter_info, 0x00,
 264                         sizeof(hostdata->madapter_info));
 265
 266         dev_info(hostdata->dev, "SRP_VERSION: %s\n", SRP_VERSION);
 267         strcpy(hostdata->madapter_info.srp_version, SRP_VERSION);
 268
 269         strscpy(hostdata->madapter_info.partition_name, partition_name,
 270                         sizeof(hostdata->madapter_info.partition_name));
 271
 272         hostdata->madapter_info.partition_number =
 273                                         cpu_to_be32(partition_number);
 274
 275         hostdata->madapter_info.mad_version = cpu_to_be32(SRP_MAD_VERSION_1);
 276         hostdata->madapter_info.os_type = cpu_to_be32(SRP_MAD_OS_LINUX);
 277 }
 278
 279 /**
 280  * ibmvscsi_reset_crq_queue() - resets a crq after a failure
 281  * @queue:      crq_queue to initialize and register
 282  * @hostdata:   ibmvscsi_host_data of host
 283  */
 284 static int ibmvscsi_reset_crq_queue(struct crq_queue *queue,
 285                                     struct ibmvscsi_host_data *hostdata)
 286 {
 287         int rc = 0;
 288         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 289
 290         /* Close the CRQ */
 291         do {
 292                 if (rc)
 293                         msleep(100);
 294                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
 295         } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
 296
 297         /* Clean out the queue */
 298         memset(queue->msgs, 0x00, PAGE_SIZE);
 299         queue->cur = 0;
 300
 301         set_adapter_info(hostdata);
 302
 303         /* And re-open it again */
 304         rc = plpar_hcall_norets(H_REG_CRQ,
 305                                 vdev->unit_address,
 306                                 queue->msg_token, PAGE_SIZE);
 307         if (rc == H_CLOSED) {
 308                 /* Adapter is good, but other end is not ready */
 309                 dev_warn(hostdata->dev, "Partner adapter not ready\n");
 310         } else if (rc != 0) {
 311                 dev_warn(hostdata->dev, "couldn't register crq--rc 0x%x\n", rc);
 312         }
 313         return rc;
 314 }
 315
 316 /**
 317  * ibmvscsi_init_crq_queue() - Initializes and registers CRQ with hypervisor
 318  * @queue:              crq_queue to initialize and register
 319  * @hostdata:           ibmvscsi_host_data of host
 320  * @max_requests:       maximum requests (unused)
 321  *
 322  * Allocates a page for messages, maps it for dma, and registers
 323  * the crq with the hypervisor.
 324  * Returns zero on success.
 325  */
 326 static int ibmvscsi_init_crq_queue(struct crq_queue *queue,
 327                                    struct ibmvscsi_host_data *hostdata,
 328                                    int max_requests)
 329 {
 330         int rc;
 331         int retrc;
 332         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 333
 334         queue->msgs = (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL);
 335
 336         if (!queue->msgs)
 337                 goto malloc_failed;
 338         queue->size = PAGE_SIZE / sizeof(*queue->msgs);
 339
 340         queue->msg_token = dma_map_single(hostdata->dev, queue->msgs,
 341                                           queue->size * sizeof(*queue->msgs),
 342                                           DMA_BIDIRECTIONAL);
 343
 344         if (dma_mapping_error(hostdata->dev, queue->msg_token))
 345                 goto map_failed;
 346
 347         gather_partition_info();
 348         set_adapter_info(hostdata);
 349
 350         retrc = rc = plpar_hcall_norets(H_REG_CRQ,
 351                                 vdev->unit_address,
 352                                 queue->msg_token, PAGE_SIZE);
 353         if (rc == H_RESOURCE)
 354                 /* maybe kexecing and resource is busy. try a reset */
 355                 rc = ibmvscsi_reset_crq_queue(queue,
 356                                               hostdata);
 357
 358         if (rc == H_CLOSED) {
 359                 /* Adapter is good, but other end is not ready */
 360                 dev_warn(hostdata->dev, "Partner adapter not ready\n");
 361                 retrc = 0;
 362         } else if (rc != 0) {
 363                 dev_warn(hostdata->dev, "Error %d opening adapter\n", rc);
 364                 goto reg_crq_failed;
 365         }
 366
 367         queue->cur = 0;
 368         spin_lock_init(&queue->lock);
 369
 370         tasklet_init(&hostdata->srp_task, (void *)ibmvscsi_task,
 371                      (unsigned long)hostdata);
 372
 373         if (request_irq(vdev->irq,
 374                         ibmvscsi_handle_event,
 375                         0, "ibmvscsi", (void *)hostdata) != 0) {
 376                 dev_err(hostdata->dev, "couldn't register irq 0x%x\n",
 377                         vdev->irq);
 378                 goto req_irq_failed;
 379         }
 380
 381         rc = vio_enable_interrupts(vdev);
 382         if (rc != 0) {
 383                 dev_err(hostdata->dev, "Error %d enabling interrupts!!!\n", rc);
 384                 goto req_irq_failed;
 385         }
 386
 387         return retrc;
 388
 389       req_irq_failed:
 390         tasklet_kill(&hostdata->srp_task);
 391         rc = 0;
 392         do {
 393                 if (rc)
 394                         msleep(100);
 395                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
 396         } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
 397       reg_crq_failed:
 398         dma_unmap_single(hostdata->dev,
 399                          queue->msg_token,
 400                          queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
 401       map_failed:
 402         free_page((unsigned long)queue->msgs);
 403       malloc_failed:
 404         return -1;
 405 }
 406
 407 /**
 408  * ibmvscsi_reenable_crq_queue() - reenables a crq after
 409  * @queue:      crq_queue to initialize and register
 410  * @hostdata:   ibmvscsi_host_data of host
 411  */
 412 static int ibmvscsi_reenable_crq_queue(struct crq_queue *queue,
 413                                        struct ibmvscsi_host_data *hostdata)
 414 {
 415         int rc = 0;
 416         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 417
 418         set_adapter_info(hostdata);
 419
 420         /* Re-enable the CRQ */
 421         do {
 422                 if (rc)
 423                         msleep(100);
 424                 rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
 425         } while ((rc == H_IN_PROGRESS) || (rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
 426
 427         if (rc)
 428                 dev_err(hostdata->dev, "Error %d enabling adapter\n", rc);
 429         return rc;
 430 }
 431
 432 /* ------------------------------------------------------------
 433  * Routines for the event pool and event structs
 434  */
 435 /**
 436  * initialize_event_pool: - Allocates and initializes the event pool for a host
 437  * @pool:       event_pool to be initialized
 438  * @size:       Number of events in pool
 439  * @hostdata:   ibmvscsi_host_data who owns the event pool
 440  *
 441  * Returns zero on success.
 442  */
 443 static int initialize_event_pool(struct event_pool *pool,
 444                                  int size, struct ibmvscsi_host_data *hostdata)
 445 {
 446         int i;
 447
 448         pool->size = size;
 449         pool->next = 0;
 450         pool->events = kcalloc(pool->size, sizeof(*pool->events), GFP_KERNEL);
 451         if (!pool->events)
 452                 return -ENOMEM;
 453
 454         pool->iu_storage =
 455             dma_alloc_coherent(hostdata->dev,
 456                                pool->size * sizeof(*pool->iu_storage),
 457                                &pool->iu_token, GFP_KERNEL);
 458         if (!pool->iu_storage) {
 459                 kfree(pool->events);
 460                 return -ENOMEM;
 461         }
 462
 463         for (i = 0; i < pool->size; ++i) {
 464                 struct srp_event_struct *evt = &pool->events[i];
 465                 memset(&evt->crq, 0x00, sizeof(evt->crq));
 466                 atomic_set(&evt->free, 1);
 467                 evt->crq.valid = VIOSRP_CRQ_CMD_RSP;
 468                 evt->crq.IU_length = cpu_to_be16(sizeof(*evt->xfer_iu));
 469                 evt->crq.IU_data_ptr = cpu_to_be64(pool->iu_token +
 470                         sizeof(*evt->xfer_iu) * i);
 471                 evt->xfer_iu = pool->iu_storage + i;
 472                 evt->hostdata = hostdata;
 473                 evt->ext_list = NULL;
 474                 evt->ext_list_token = 0;
 475         }
 476
 477         return 0;
 478 }
 479
 480 /**
 481  * release_event_pool() - Frees memory of an event pool of a host
 482  * @pool:       event_pool to be released
 483  * @hostdata:   ibmvscsi_host_data who owns the even pool
 484  *
 485  * Returns zero on success.
 486  */
 487 static void release_event_pool(struct event_pool *pool,
 488                                struct ibmvscsi_host_data *hostdata)
 489 {
 490         int i, in_use = 0;
 491         for (i = 0; i < pool->size; ++i) {
 492                 if (atomic_read(&pool->events[i].free) != 1)
 493                         ++in_use;
 494                 if (pool->events[i].ext_list) {
 495                         dma_free_coherent(hostdata->dev,
 496                                   SG_ALL * sizeof(struct srp_direct_buf),
 497                                   pool->events[i].ext_list,
 498                                   pool->events[i].ext_list_token);
 499                 }
 500         }
 501         if (in_use)
 502                 dev_warn(hostdata->dev, "releasing event pool with %d "
 503                          "events still in use?\n", in_use);
 504         kfree(pool->events);
 505         dma_free_coherent(hostdata->dev,
 506                           pool->size * sizeof(*pool->iu_storage),
 507                           pool->iu_storage, pool->iu_token);
 508 }
 509
 510 /**
 511  * valid_event_struct: - Determines if event is valid.
 512  * @pool:       event_pool that contains the event
 513  * @evt:        srp_event_struct to be checked for validity
 514  *
 515  * Returns zero if event is invalid, one otherwise.
 516 */
 517 static int valid_event_struct(struct event_pool *pool,
 518                                 struct srp_event_struct *evt)
 519 {
 520         int index = evt - pool->events;
 521         if (index < 0 || index >= pool->size)   /* outside of bounds */
 522                 return 0;
 523         if (evt != pool->events + index)        /* unaligned */
 524                 return 0;
 525         return 1;
 526 }
 527
 528 /**
 529  * free_event_struct() - Changes status of event to "free"
 530  * @pool:       event_pool that contains the event
 531  * @evt:        srp_event_struct to be modified
 532  */
 533 static void free_event_struct(struct event_pool *pool,
 534                                        struct srp_event_struct *evt)
 535 {
 536         if (!valid_event_struct(pool, evt)) {
 537                 dev_err(evt->hostdata->dev, "Freeing invalid event_struct %p "
 538                         "(not in pool %p)\n", evt, pool->events);
 539                 return;
 540         }
 541         if (atomic_inc_return(&evt->free) != 1) {
 542                 dev_err(evt->hostdata->dev, "Freeing event_struct %p "
 543                         "which is not in use!\n", evt);
 544                 return;
 545         }
 546 }
 547
 548 /**
 549  * get_event_struct() - Gets the next free event in pool
 550  * @pool:       event_pool that contains the events to be searched
 551  *
 552  * Returns the next event in "free" state, and NULL if none are free.
 553  * Note that no synchronization is done here, we assume the host_lock
 554  * will syncrhonze things.
 555 */
 556 static struct srp_event_struct *get_event_struct(struct event_pool *pool)
 557 {
 558         int i;
 559         int poolsize = pool->size;
 560         int offset = pool->next;
 561
 562         for (i = 0; i < poolsize; i++) {
 563                 offset = (offset + 1) % poolsize;
 564                 if (!atomic_dec_if_positive(&pool->events[offset].free)) {
 565                         pool->next = offset;
 566                         return &pool->events[offset];
 567                 }
 568         }
 569
 570         printk(KERN_ERR "ibmvscsi: found no event struct in pool!\n");
 571         return NULL;
 572 }
 573
 574 /**
 575  * init_event_struct: Initialize fields in an event struct that are always
 576  *                    required.
 577  * @evt_struct: The event
 578  * @done:       Routine to call when the event is responded to
 579  * @format:     SRP or MAD format
 580  * @timeout:    timeout value set in the CRQ
 581  */
 582 static void init_event_struct(struct srp_event_struct *evt_struct,
 583                               void (*done) (struct srp_event_struct *),
 584                               u8 format,
 585                               int timeout)
 586 {
 587         evt_struct->cmnd = NULL;
 588         evt_struct->cmnd_done = NULL;
 589         evt_struct->sync_srp = NULL;
 590         evt_struct->crq.format = format;
 591         evt_struct->crq.timeout = cpu_to_be16(timeout);
 592         evt_struct->done = done;
 593 }
 594
 595 /* ------------------------------------------------------------
 596  * Routines for receiving SCSI responses from the hosting partition
 597  */
 598
 599 /*
 600  * set_srp_direction: Set the fields in the srp related to data
 601  *     direction and number of buffers based on the direction in
 602  *     the scsi_cmnd and the number of buffers
 603  */
 604 static void set_srp_direction(struct scsi_cmnd *cmd,
 605                               struct srp_cmd *srp_cmd,
 606                               int numbuf)
 607 {
 608         u8 fmt;
 609
 610         if (numbuf == 0)
 611                 return;
 612
 613         if (numbuf == 1)
 614                 fmt = SRP_DATA_DESC_DIRECT;
 615         else {
 616                 fmt = SRP_DATA_DESC_INDIRECT;
 617                 numbuf = min(numbuf, MAX_INDIRECT_BUFS);
 618
 619                 if (cmd->sc_data_direction == DMA_TO_DEVICE)
 620                         srp_cmd->data_out_desc_cnt = numbuf;
 621                 else
 622                         srp_cmd->data_in_desc_cnt = numbuf;
 623         }
 624
 625         if (cmd->sc_data_direction == DMA_TO_DEVICE)
 626                 srp_cmd->buf_fmt = fmt << 4;
 627         else
 628                 srp_cmd->buf_fmt = fmt;
 629 }
 630
 631 /**
 632  * unmap_cmd_data: - Unmap data pointed in srp_cmd based on the format
 633  * @cmd:        srp_cmd whose additional_data member will be unmapped
 634  * @evt_struct: the event
 635  * @dev:        device for which the memory is mapped
 636  */
 637 static void unmap_cmd_data(struct srp_cmd *cmd,
 638                            struct srp_event_struct *evt_struct,
 639                            struct device *dev)
 640 {
 641         u8 out_fmt, in_fmt;
 642
 643         out_fmt = cmd->buf_fmt >> 4;
 644         in_fmt = cmd->buf_fmt & ((1U << 4) - 1);
 645
 646         if (out_fmt == SRP_NO_DATA_DESC && in_fmt == SRP_NO_DATA_DESC)
 647                 return;
 648
 649         if (evt_struct->cmnd)
 650                 scsi_dma_unmap(evt_struct->cmnd);
 651 }
 652
 653 static int map_sg_list(struct scsi_cmnd *cmd, int nseg,
 654                        struct srp_direct_buf *md)
 655 {
 656         int i;
 657         struct scatterlist *sg;
 658         u64 total_length = 0;
 659
 660         scsi_for_each_sg(cmd, sg, nseg, i) {
 661                 struct srp_direct_buf *descr = md + i;
 662                 descr->va = cpu_to_be64(sg_dma_address(sg));
 663                 descr->len = cpu_to_be32(sg_dma_len(sg));
 664                 descr->key = 0;
 665                 total_length += sg_dma_len(sg);
 666         }
 667         return total_length;
 668 }
 669
 670 /**
 671  * map_sg_data: - Maps dma for a scatterlist and initializes descriptor fields
 672  * @cmd:        struct scsi_cmnd with the scatterlist
 673  * @evt_struct: struct srp_event_struct to map
 674  * @srp_cmd:    srp_cmd that contains the memory descriptor
 675  * @dev:        device for which to map dma memory
 676  *
 677  * Called by map_data_for_srp_cmd() when building srp cmd from scsi cmd.
 678  * Returns 1 on success.
 679 */
 680 static int map_sg_data(struct scsi_cmnd *cmd,
 681                        struct srp_event_struct *evt_struct,
 682                        struct srp_cmd *srp_cmd, struct device *dev)
 683 {
 684
 685         int sg_mapped;
 686         u64 total_length = 0;
 687         struct srp_direct_buf *data =
 688                 (struct srp_direct_buf *) srp_cmd->add_data;
 689         struct srp_indirect_buf *indirect =
 690                 (struct srp_indirect_buf *) data;
 691
 692         sg_mapped = scsi_dma_map(cmd);
 693         if (!sg_mapped)
 694                 return 1;
 695         else if (sg_mapped < 0)
 696                 return 0;
 697
 698         set_srp_direction(cmd, srp_cmd, sg_mapped);
 699
 700         /* special case; we can use a single direct descriptor */
 701         if (sg_mapped == 1) {
 702                 map_sg_list(cmd, sg_mapped, data);
 703                 return 1;
 704         }
 705
 706         indirect->table_desc.va = 0;
 707         indirect->table_desc.len = cpu_to_be32(sg_mapped *
 708                                                sizeof(struct srp_direct_buf));
 709         indirect->table_desc.key = 0;
 710
 711         if (sg_mapped <= MAX_INDIRECT_BUFS) {
 712                 total_length = map_sg_list(cmd, sg_mapped,
 713                                            &indirect->desc_list[0]);
 714                 indirect->len = cpu_to_be32(total_length);
 715                 return 1;
 716         }
 717
 718         /* get indirect table */
 719         if (!evt_struct->ext_list) {
 720                 evt_struct->ext_list = dma_alloc_coherent(dev,
 721                                            SG_ALL * sizeof(struct srp_direct_buf),
 722                                            &evt_struct->ext_list_token, 0);
 723                 if (!evt_struct->ext_list) {
 724                         if (!firmware_has_feature(FW_FEATURE_CMO))
 725                                 sdev_printk(KERN_ERR, cmd->device,
 726                                             "Can't allocate memory "
 727                                             "for indirect table\n");
 728                         scsi_dma_unmap(cmd);
 729                         return 0;
 730                 }
 731         }
 732
 733         total_length = map_sg_list(cmd, sg_mapped, evt_struct->ext_list);
 734
 735         indirect->len = cpu_to_be32(total_length);
 736         indirect->table_desc.va = cpu_to_be64(evt_struct->ext_list_token);
 737         indirect->table_desc.len = cpu_to_be32(sg_mapped *
 738                                                sizeof(indirect->desc_list[0]));
 739         memcpy(indirect->desc_list, evt_struct->ext_list,
 740                MAX_INDIRECT_BUFS * sizeof(struct srp_direct_buf));
 741         return 1;
 742 }
 743
 744 /**
 745  * map_data_for_srp_cmd: - Calls functions to map data for srp cmds
 746  * @cmd:        struct scsi_cmnd with the memory to be mapped
 747  * @evt_struct: struct srp_event_struct to map
 748  * @srp_cmd:    srp_cmd that contains the memory descriptor
 749  * @dev:        dma device for which to map dma memory
 750  *
 751  * Called by scsi_cmd_to_srp_cmd() when converting scsi cmds to srp cmds
 752  * Returns 1 on success.
 753 */
 754 static int map_data_for_srp_cmd(struct scsi_cmnd *cmd,
 755                                 struct srp_event_struct *evt_struct,
 756                                 struct srp_cmd *srp_cmd, struct device *dev)
 757 {
 758         switch (cmd->sc_data_direction) {
 759         case DMA_FROM_DEVICE:
 760         case DMA_TO_DEVICE:
 761                 break;
 762         case DMA_NONE:
 763                 return 1;
 764         case DMA_BIDIRECTIONAL:
 765                 sdev_printk(KERN_ERR, cmd->device,
 766                             "Can't map DMA_BIDIRECTIONAL to read/write\n");
 767                 return 0;
 768         default:
 769                 sdev_printk(KERN_ERR, cmd->device,
 770                             "Unknown data direction 0x%02x; can't map!\n",
 771                             cmd->sc_data_direction);
 772                 return 0;
 773         }
 774
 775         return map_sg_data(cmd, evt_struct, srp_cmd, dev);
 776 }
 777
 778 /**
 779  * purge_requests: Our virtual adapter just shut down.  purge any sent requests
 780  * @hostdata:    the adapter
 781  * @error_code:  error code to return as the 'result'
 782  */
 783 static void purge_requests(struct ibmvscsi_host_data *hostdata, int error_code)
 784 {
 785         struct srp_event_struct *evt;
 786         unsigned long flags;
 787
 788         spin_lock_irqsave(hostdata->host->host_lock, flags);
 789         while (!list_empty(&hostdata->sent)) {
 790                 evt = list_first_entry(&hostdata->sent, struct srp_event_struct, list);
 791                 list_del(&evt->list);
 792                 del_timer(&evt->timer);
 793
 794                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
 795                 if (evt->cmnd) {
 796                         evt->cmnd->result = (error_code << 16);
 797                         unmap_cmd_data(&evt->iu.srp.cmd, evt,
 798                                        evt->hostdata->dev);
 799                         if (evt->cmnd_done)
 800                                 evt->cmnd_done(evt->cmnd);
 801                 } else if (evt->done && evt->crq.format != VIOSRP_MAD_FORMAT &&
 802                            evt->iu.srp.login_req.opcode != SRP_LOGIN_REQ)
 803                         evt->done(evt);
 804                 free_event_struct(&evt->hostdata->pool, evt);
 805                 spin_lock_irqsave(hostdata->host->host_lock, flags);
 806         }
 807         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
 808 }
 809
 810 /**
 811  * ibmvscsi_set_request_limit - Set the adapter request_limit in response to
 812  * an adapter failure, reset, or SRP Login. Done under host lock to prevent
 813  * race with SCSI command submission.
 814  * @hostdata:   adapter to adjust
 815  * @limit:      new request limit
 816  */
 817 static void ibmvscsi_set_request_limit(struct ibmvscsi_host_data *hostdata, int limit)
 818 {
 819         unsigned long flags;
 820
 821         spin_lock_irqsave(hostdata->host->host_lock, flags);
 822         atomic_set(&hostdata->request_limit, limit);
 823         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
 824 }
 825
 826 /**
 827  * ibmvscsi_reset_host - Reset the connection to the server
 828  * @hostdata:   struct ibmvscsi_host_data to reset
 829 */
 830 static void ibmvscsi_reset_host(struct ibmvscsi_host_data *hostdata)
 831 {
 832         scsi_block_requests(hostdata->host);
 833         ibmvscsi_set_request_limit(hostdata, 0);
 834
 835         purge_requests(hostdata, DID_ERROR);
 836         hostdata->action = IBMVSCSI_HOST_ACTION_RESET;
 837         wake_up(&hostdata->work_wait_q);
 838 }
 839
 840 /**
 841  * ibmvscsi_timeout - Internal command timeout handler
 842  * @t:  struct srp_event_struct that timed out
 843  *
 844  * Called when an internally generated command times out
 845 */
 846 static void ibmvscsi_timeout(struct timer_list *t)
 847 {
 848         struct srp_event_struct *evt_struct = from_timer(evt_struct, t, timer);
 849         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
 850
 851         dev_err(hostdata->dev, "Command timed out (%x). Resetting connection\n",
 852                 evt_struct->iu.srp.cmd.opcode);
 853
 854         ibmvscsi_reset_host(hostdata);
 855 }
 856
 857
 858 /* ------------------------------------------------------------
 859  * Routines for sending and receiving SRPs
 860  */
 861 /**
 862  * ibmvscsi_send_srp_event: - Transforms event to u64 array and calls send_crq()
 863  * @evt_struct: evt_struct to be sent
 864  * @hostdata:   ibmvscsi_host_data of host
 865  * @timeout:    timeout in seconds - 0 means do not time command
 866  *
 867  * Returns the value returned from ibmvscsi_send_crq(). (Zero for success)
 868  * Note that this routine assumes that host_lock is held for synchronization
 869 */
 870 static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
 871                                    struct ibmvscsi_host_data *hostdata,
 872                                    unsigned long timeout)
 873 {
 874         __be64 *crq_as_u64 = (__be64 *)&evt_struct->crq;
 875         int request_status = 0;
 876         int rc;
 877         int srp_req = 0;
 878
 879         /* If we have exhausted our request limit, just fail this request,
 880          * unless it is for a reset or abort.
 881          * Note that there are rare cases involving driver generated requests
 882          * (such as task management requests) that the mid layer may think we
 883          * can handle more requests (can_queue) when we actually can't
 884          */
 885         if (evt_struct->crq.format == VIOSRP_SRP_FORMAT) {
 886                 srp_req = 1;
 887                 request_status =
 888                         atomic_dec_if_positive(&hostdata->request_limit);
 889                 /* If request limit was -1 when we started, it is now even
 890                  * less than that
 891                  */
 892                 if (request_status < -1)
 893                         goto send_error;
 894                 /* Otherwise, we may have run out of requests. */
 895                 /* If request limit was 0 when we started the adapter is in the
 896                  * process of performing a login with the server adapter, or
 897                  * we may have run out of requests.
 898                  */
 899                 else if (request_status == -1 &&
 900                          evt_struct->iu.srp.login_req.opcode != SRP_LOGIN_REQ)
 901                         goto send_busy;
 902                 /* Abort and reset calls should make it through.
 903                  * Nothing except abort and reset should use the last two
 904                  * slots unless we had two or less to begin with.
 905                  */
 906                 else if (request_status < 2 &&
 907                          evt_struct->iu.srp.cmd.opcode != SRP_TSK_MGMT) {
 908                         /* In the case that we have less than two requests
 909                          * available, check the server limit as a combination
 910                          * of the request limit and the number of requests
 911                          * in-flight (the size of the send list).  If the
 912                          * server limit is greater than 2, return busy so
 913                          * that the last two are reserved for reset and abort.
 914                          */
 915                         int server_limit = request_status;
 916                         struct srp_event_struct *tmp_evt;
 917
 918                         list_for_each_entry(tmp_evt, &hostdata->sent, list) {
 919                                 server_limit++;
 920                         }
 921
 922                         if (server_limit > 2)
 923                                 goto send_busy;
 924                 }
 925         }
 926
 927         /* Copy the IU into the transfer area */
 928         *evt_struct->xfer_iu = evt_struct->iu;
 929         evt_struct->xfer_iu->srp.rsp.tag = (u64)evt_struct;
 930
 931         /* Add this to the sent list.  We need to do this
 932          * before we actually send
 933          * in case it comes back REALLY fast
 934          */
 935         list_add_tail(&evt_struct->list, &hostdata->sent);
 936
 937         timer_setup(&evt_struct->timer, ibmvscsi_timeout, 0);
 938         if (timeout) {
 939                 evt_struct->timer.expires = jiffies + (timeout * HZ);
 940                 add_timer(&evt_struct->timer);
 941         }
 942
 943         rc = ibmvscsi_send_crq(hostdata, be64_to_cpu(crq_as_u64[0]),
 944                                be64_to_cpu(crq_as_u64[1]));
 945         if (rc != 0) {
 946                 list_del(&evt_struct->list);
 947                 del_timer(&evt_struct->timer);
 948
 949                 /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY.
 950                  * Firmware will send a CRQ with a transport event (0xFF) to
 951                  * tell this client what has happened to the transport.  This
 952                  * will be handled in ibmvscsi_handle_crq()
 953                  */
 954                 if (rc == H_CLOSED) {
 955                         dev_warn(hostdata->dev, "send warning. "
 956                                  "Receive queue closed, will retry.\n");
 957                         goto send_busy;
 958                 }
 959                 dev_err(hostdata->dev, "send error %d\n", rc);
 960                 if (srp_req)
 961                         atomic_inc(&hostdata->request_limit);
 962                 goto send_error;
 963         }
 964
 965         return 0;
 966
 967  send_busy:
 968         unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev);
 969
 970         free_event_struct(&hostdata->pool, evt_struct);
 971         if (srp_req && request_status != -1)
 972                 atomic_inc(&hostdata->request_limit);
 973         return SCSI_MLQUEUE_HOST_BUSY;
 974
 975  send_error:
 976         unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev);
 977
 978         if (evt_struct->cmnd != NULL) {
 979                 evt_struct->cmnd->result = DID_ERROR << 16;
 980                 evt_struct->cmnd_done(evt_struct->cmnd);
 981         } else if (evt_struct->done)
 982                 evt_struct->done(evt_struct);
 983
 984         free_event_struct(&hostdata->pool, evt_struct);
 985         return 0;
 986 }
 987
 988 /**
 989  * handle_cmd_rsp: -  Handle responses from commands
 990  * @evt_struct: srp_event_struct to be handled
 991  *
 992  * Used as a callback by when sending scsi cmds.
 993  * Gets called by ibmvscsi_handle_crq()
 994 */
 995 static void handle_cmd_rsp(struct srp_event_struct *evt_struct)
 996 {
 997         struct srp_rsp *rsp = &evt_struct->xfer_iu->srp.rsp;
 998         struct scsi_cmnd *cmnd = evt_struct->cmnd;
 999
1000         if (unlikely(rsp->opcode != SRP_RSP)) {
1001                 if (printk_ratelimit())
1002                         dev_warn(evt_struct->hostdata->dev,
1003                                  "bad SRP RSP type %#02x\n", rsp->opcode);
1004         }
1005
1006         if (cmnd) {
1007                 cmnd->result |= rsp->status;
1008                 if (scsi_status_is_check_condition(cmnd->result))
1009                         memcpy(cmnd->sense_buffer,
1010                                rsp->data,
1011                                be32_to_cpu(rsp->sense_data_len));
1012                 unmap_cmd_data(&evt_struct->iu.srp.cmd,
1013                                evt_struct,
1014                                evt_struct->hostdata->dev);
1015
1016                 if (rsp->flags & SRP_RSP_FLAG_DOOVER)
1017                         scsi_set_resid(cmnd,
1018                                        be32_to_cpu(rsp->data_out_res_cnt));
1019                 else if (rsp->flags & SRP_RSP_FLAG_DIOVER)
1020                         scsi_set_resid(cmnd, be32_to_cpu(rsp->data_in_res_cnt));
1021         }
1022
1023         if (evt_struct->cmnd_done)
1024                 evt_struct->cmnd_done(cmnd);
1025 }
1026
1027 /**
1028  * lun_from_dev: - Returns the lun of the scsi device
1029  * @dev:        struct scsi_device
1030  *
1031 */
1032 static inline u16 lun_from_dev(struct scsi_device *dev)
1033 {
1034         return (0x2 << 14) | (dev->id << 8) | (dev->channel << 5) | dev->lun;
1035 }
1036
1037 /**
1038  * ibmvscsi_queuecommand_lck() - The queuecommand function of the scsi template
1039  * @cmnd:       struct scsi_cmnd to be executed
1040  * @done:       Callback function to be called when cmd is completed
1041 */
1042 static int ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd)
1043 {
1044         void (*done)(struct scsi_cmnd *) = scsi_done;
1045         struct srp_cmd *srp_cmd;
1046         struct srp_event_struct *evt_struct;
1047         struct srp_indirect_buf *indirect;
1048         struct ibmvscsi_host_data *hostdata = shost_priv(cmnd->device->host);
1049         u16 lun = lun_from_dev(cmnd->device);
1050         u8 out_fmt, in_fmt;
1051
1052         cmnd->result = (DID_OK << 16);
1053         evt_struct = get_event_struct(&hostdata->pool);
1054         if (!evt_struct)
1055                 return SCSI_MLQUEUE_HOST_BUSY;
1056
1057         /* Set up the actual SRP IU */
1058         BUILD_BUG_ON(sizeof(evt_struct->iu.srp) != SRP_MAX_IU_LEN);
1059         memset(&evt_struct->iu.srp, 0x00, sizeof(evt_struct->iu.srp));
1060         srp_cmd = &evt_struct->iu.srp.cmd;
1061         srp_cmd->opcode = SRP_CMD;
1062         memcpy(srp_cmd->cdb, cmnd->cmnd, sizeof(srp_cmd->cdb));
1063         int_to_scsilun(lun, &srp_cmd->lun);
1064
1065         if (!map_data_for_srp_cmd(cmnd, evt_struct, srp_cmd, hostdata->dev)) {
1066                 if (!firmware_has_feature(FW_FEATURE_CMO))
1067                         sdev_printk(KERN_ERR, cmnd->device,
1068                                     "couldn't convert cmd to srp_cmd\n");
1069                 free_event_struct(&hostdata->pool, evt_struct);
1070                 return SCSI_MLQUEUE_HOST_BUSY;
1071         }
1072
1073         init_event_struct(evt_struct,
1074                           handle_cmd_rsp,
1075                           VIOSRP_SRP_FORMAT,
1076                           scsi_cmd_to_rq(cmnd)->timeout / HZ);
1077
1078         evt_struct->cmnd = cmnd;
1079         evt_struct->cmnd_done = done;
1080
1081         /* Fix up dma address of the buffer itself */
1082         indirect = (struct srp_indirect_buf *) srp_cmd->add_data;
1083         out_fmt = srp_cmd->buf_fmt >> 4;
1084         in_fmt = srp_cmd->buf_fmt & ((1U << 4) - 1);
1085         if ((in_fmt == SRP_DATA_DESC_INDIRECT ||
1086              out_fmt == SRP_DATA_DESC_INDIRECT) &&
1087             indirect->table_desc.va == 0) {
1088                 indirect->table_desc.va =
1089                         cpu_to_be64(be64_to_cpu(evt_struct->crq.IU_data_ptr) +
1090                         offsetof(struct srp_cmd, add_data) +
1091                         offsetof(struct srp_indirect_buf, desc_list));
1092         }
1093
1094         return ibmvscsi_send_srp_event(evt_struct, hostdata, 0);
1095 }
1096
1097 static DEF_SCSI_QCMD(ibmvscsi_queuecommand)
1098
1099 /* ------------------------------------------------------------
1100  * Routines for driver initialization
1101  */
1102
1103 /**
1104  * map_persist_bufs: - Pre-map persistent data for adapter logins
1105  * @hostdata:   ibmvscsi_host_data of host
1106  *
1107  * Map the capabilities and adapter info DMA buffers to avoid runtime failures.
1108  * Return 1 on error, 0 on success.
1109  */
1110 static int map_persist_bufs(struct ibmvscsi_host_data *hostdata)
1111 {
1112
1113         hostdata->caps_addr = dma_map_single(hostdata->dev, &hostdata->caps,
1114                                              sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1115
1116         if (dma_mapping_error(hostdata->dev, hostdata->caps_addr)) {
1117                 dev_err(hostdata->dev, "Unable to map capabilities buffer!\n");
1118                 return 1;
1119         }
1120
1121         hostdata->adapter_info_addr = dma_map_single(hostdata->dev,
1122                                                      &hostdata->madapter_info,
1123                                                      sizeof(hostdata->madapter_info),
1124                                                      DMA_BIDIRECTIONAL);
1125         if (dma_mapping_error(hostdata->dev, hostdata->adapter_info_addr)) {
1126                 dev_err(hostdata->dev, "Unable to map adapter info buffer!\n");
1127                 dma_unmap_single(hostdata->dev, hostdata->caps_addr,
1128                                  sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1129                 return 1;
1130         }
1131
1132         return 0;
1133 }
1134
1135 /**
1136  * unmap_persist_bufs: - Unmap persistent data needed for adapter logins
1137  * @hostdata:   ibmvscsi_host_data of host
1138  *
1139  * Unmap the capabilities and adapter info DMA buffers
1140  */
1141 static void unmap_persist_bufs(struct ibmvscsi_host_data *hostdata)
1142 {
1143         dma_unmap_single(hostdata->dev, hostdata->caps_addr,
1144                          sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1145
1146         dma_unmap_single(hostdata->dev, hostdata->adapter_info_addr,
1147                          sizeof(hostdata->madapter_info), DMA_BIDIRECTIONAL);
1148 }
1149
1150 /**
1151  * login_rsp: - Handle response to SRP login request
1152  * @evt_struct: srp_event_struct with the response
1153  *
1154  * Used as a "done" callback by when sending srp_login. Gets called
1155  * by ibmvscsi_handle_crq()
1156 */
1157 static void login_rsp(struct srp_event_struct *evt_struct)
1158 {
1159         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1160         switch (evt_struct->xfer_iu->srp.login_rsp.opcode) {
1161         case SRP_LOGIN_RSP:     /* it worked! */
1162                 break;
1163         case SRP_LOGIN_REJ:     /* refused! */
1164                 dev_info(hostdata->dev, "SRP_LOGIN_REJ reason %u\n",
1165                          evt_struct->xfer_iu->srp.login_rej.reason);
1166                 /* Login failed.  */
1167                 ibmvscsi_set_request_limit(hostdata, -1);
1168                 return;
1169         default:
1170                 dev_err(hostdata->dev, "Invalid login response typecode 0x%02x!\n",
1171                         evt_struct->xfer_iu->srp.login_rsp.opcode);
1172                 /* Login failed.  */
1173                 ibmvscsi_set_request_limit(hostdata, -1);
1174                 return;
1175         }
1176
1177         dev_info(hostdata->dev, "SRP_LOGIN succeeded\n");
1178         hostdata->client_migrated = 0;
1179
1180         /* Now we know what the real request-limit is.
1181          * This value is set rather than added to request_limit because
1182          * request_limit could have been set to -1 by this client.
1183          */
1184         ibmvscsi_set_request_limit(hostdata,
1185                    be32_to_cpu(evt_struct->xfer_iu->srp.login_rsp.req_lim_delta));
1186
1187         /* If we had any pending I/Os, kick them */
1188         hostdata->action = IBMVSCSI_HOST_ACTION_UNBLOCK;
1189         wake_up(&hostdata->work_wait_q);
1190 }
1191
1192 /**
1193  * send_srp_login: - Sends the srp login
1194  * @hostdata:   ibmvscsi_host_data of host
1195  *
1196  * Returns zero if successful.
1197 */
1198 static int send_srp_login(struct ibmvscsi_host_data *hostdata)
1199 {
1200         int rc;
1201         unsigned long flags;
1202         struct srp_login_req *login;
1203         struct srp_event_struct *evt_struct = get_event_struct(&hostdata->pool);
1204
1205         BUG_ON(!evt_struct);
1206         init_event_struct(evt_struct, login_rsp,
1207                           VIOSRP_SRP_FORMAT, login_timeout);
1208
1209         login = &evt_struct->iu.srp.login_req;
1210         memset(login, 0, sizeof(*login));
1211         login->opcode = SRP_LOGIN_REQ;
1212         login->req_it_iu_len = cpu_to_be32(sizeof(union srp_iu));
1213         login->req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
1214                                          SRP_BUF_FORMAT_INDIRECT);
1215
1216         /* Start out with a request limit of 0, since this is negotiated in
1217          * the login request we are just sending and login requests always
1218          * get sent by the driver regardless of request_limit.
1219          */
1220         ibmvscsi_set_request_limit(hostdata, 0);
1221
1222         spin_lock_irqsave(hostdata->host->host_lock, flags);
1223         rc = ibmvscsi_send_srp_event(evt_struct, hostdata, login_timeout * 2);
1224         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1225         dev_info(hostdata->dev, "sent SRP login\n");
1226         return rc;
1227 };
1228
1229 /**
1230  * capabilities_rsp: - Handle response to MAD adapter capabilities request
1231  * @evt_struct: srp_event_struct with the response
1232  *
1233  * Used as a "done" callback by when sending adapter_info.
1234  */
1235 static void capabilities_rsp(struct srp_event_struct *evt_struct)
1236 {
1237         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1238
1239         if (evt_struct->xfer_iu->mad.capabilities.common.status) {
1240                 dev_err(hostdata->dev, "error 0x%X getting capabilities info\n",
1241                         evt_struct->xfer_iu->mad.capabilities.common.status);
1242         } else {
1243                 if (hostdata->caps.migration.common.server_support !=
1244                     cpu_to_be16(SERVER_SUPPORTS_CAP))
1245                         dev_info(hostdata->dev, "Partition migration not supported\n");
1246
1247                 if (client_reserve) {
1248                         if (hostdata->caps.reserve.common.server_support ==
1249                             cpu_to_be16(SERVER_SUPPORTS_CAP))
1250                                 dev_info(hostdata->dev, "Client reserve enabled\n");
1251                         else
1252                                 dev_info(hostdata->dev, "Client reserve not supported\n");
1253                 }
1254         }
1255
1256         send_srp_login(hostdata);
1257 }
1258
1259 /**
1260  * send_mad_capabilities: - Sends the mad capabilities request
1261  *      and stores the result so it can be retrieved with
1262  * @hostdata:   ibmvscsi_host_data of host
1263  */
1264 static void send_mad_capabilities(struct ibmvscsi_host_data *hostdata)
1265 {
1266         struct viosrp_capabilities *req;
1267         struct srp_event_struct *evt_struct;
1268         unsigned long flags;
1269         struct device_node *of_node = hostdata->dev->of_node;
1270         const char *location;
1271
1272         evt_struct = get_event_struct(&hostdata->pool);
1273         BUG_ON(!evt_struct);
1274
1275         init_event_struct(evt_struct, capabilities_rsp,
1276                           VIOSRP_MAD_FORMAT, info_timeout);
1277
1278         req = &evt_struct->iu.mad.capabilities;
1279         memset(req, 0, sizeof(*req));
1280
1281         hostdata->caps.flags = cpu_to_be32(CAP_LIST_SUPPORTED);
1282         if (hostdata->client_migrated)
1283                 hostdata->caps.flags |= cpu_to_be32(CLIENT_MIGRATED);
1284
1285         strscpy(hostdata->caps.name, dev_name(&hostdata->host->shost_gendev),
1286                 sizeof(hostdata->caps.name));
1287
1288         location = of_get_property(of_node, "ibm,loc-code", NULL);
1289         location = location ? location : dev_name(hostdata->dev);
1290         strscpy(hostdata->caps.loc, location, sizeof(hostdata->caps.loc));
1291
1292         req->common.type = cpu_to_be32(VIOSRP_CAPABILITIES_TYPE);
1293         req->buffer = cpu_to_be64(hostdata->caps_addr);
1294
1295         hostdata->caps.migration.common.cap_type =
1296                                 cpu_to_be32(MIGRATION_CAPABILITIES);
1297         hostdata->caps.migration.common.length =
1298                                 cpu_to_be16(sizeof(hostdata->caps.migration));
1299         hostdata->caps.migration.common.server_support =
1300                                 cpu_to_be16(SERVER_SUPPORTS_CAP);
1301         hostdata->caps.migration.ecl = cpu_to_be32(1);
1302
1303         if (client_reserve) {
1304                 hostdata->caps.reserve.common.cap_type =
1305                                         cpu_to_be32(RESERVATION_CAPABILITIES);
1306                 hostdata->caps.reserve.common.length =
1307                                 cpu_to_be16(sizeof(hostdata->caps.reserve));
1308                 hostdata->caps.reserve.common.server_support =
1309                                 cpu_to_be16(SERVER_SUPPORTS_CAP);
1310                 hostdata->caps.reserve.type =
1311                                 cpu_to_be32(CLIENT_RESERVE_SCSI_2);
1312                 req->common.length =
1313                                 cpu_to_be16(sizeof(hostdata->caps));
1314         } else
1315                 req->common.length = cpu_to_be16(sizeof(hostdata->caps) -
1316                                                 sizeof(hostdata->caps.reserve));
1317
1318         spin_lock_irqsave(hostdata->host->host_lock, flags);
1319         if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2))
1320                 dev_err(hostdata->dev, "couldn't send CAPABILITIES_REQ!\n");
1321         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1322 };
1323
1324 /**
1325  * fast_fail_rsp: - Handle response to MAD enable fast fail
1326  * @evt_struct: srp_event_struct with the response
1327  *
1328  * Used as a "done" callback by when sending enable fast fail. Gets called
1329  * by ibmvscsi_handle_crq()
1330  */
1331 static void fast_fail_rsp(struct srp_event_struct *evt_struct)
1332 {
1333         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1334         u16 status = be16_to_cpu(evt_struct->xfer_iu->mad.fast_fail.common.status);
1335
1336         if (status == VIOSRP_MAD_NOT_SUPPORTED)
1337                 dev_err(hostdata->dev, "fast_fail not supported in server\n");
1338         else if (status == VIOSRP_MAD_FAILED)
1339                 dev_err(hostdata->dev, "fast_fail request failed\n");
1340         else if (status != VIOSRP_MAD_SUCCESS)
1341                 dev_err(hostdata->dev, "error 0x%X enabling fast_fail\n", status);
1342
1343         send_mad_capabilities(hostdata);
1344 }
1345
1346 /**
1347  * enable_fast_fail() - Start host initialization
1348  * @hostdata:   ibmvscsi_host_data of host
1349  *
1350  * Returns zero if successful.
1351  */
1352 static int enable_fast_fail(struct ibmvscsi_host_data *hostdata)
1353 {
1354         int rc;
1355         unsigned long flags;
1356         struct viosrp_fast_fail *fast_fail_mad;
1357         struct srp_event_struct *evt_struct;
1358
1359         if (!fast_fail) {
1360                 send_mad_capabilities(hostdata);
1361                 return 0;
1362         }
1363
1364         evt_struct = get_event_struct(&hostdata->pool);
1365         BUG_ON(!evt_struct);
1366
1367         init_event_struct(evt_struct, fast_fail_rsp, VIOSRP_MAD_FORMAT, info_timeout);
1368
1369         fast_fail_mad = &evt_struct->iu.mad.fast_fail;
1370         memset(fast_fail_mad, 0, sizeof(*fast_fail_mad));
1371         fast_fail_mad->common.type = cpu_to_be32(VIOSRP_ENABLE_FAST_FAIL);
1372         fast_fail_mad->common.length = cpu_to_be16(sizeof(*fast_fail_mad));
1373
1374         spin_lock_irqsave(hostdata->host->host_lock, flags);
1375         rc = ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2);
1376         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1377         return rc;
1378 }
1379
1380 /**
1381  * adapter_info_rsp: - Handle response to MAD adapter info request
1382  * @evt_struct: srp_event_struct with the response
1383  *
1384  * Used as a "done" callback by when sending adapter_info. Gets called
1385  * by ibmvscsi_handle_crq()
1386 */
1387 static void adapter_info_rsp(struct srp_event_struct *evt_struct)
1388 {
1389         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1390
1391         if (evt_struct->xfer_iu->mad.adapter_info.common.status) {
1392                 dev_err(hostdata->dev, "error %d getting adapter info\n",
1393                         evt_struct->xfer_iu->mad.adapter_info.common.status);
1394         } else {
1395                 dev_info(hostdata->dev, "host srp version: %s, "
1396                          "host partition %s (%d), OS %d, max io %u\n",
1397                          hostdata->madapter_info.srp_version,
1398                          hostdata->madapter_info.partition_name,
1399                          be32_to_cpu(hostdata->madapter_info.partition_number),
1400                          be32_to_cpu(hostdata->madapter_info.os_type),
1401                          be32_to_cpu(hostdata->madapter_info.port_max_txu[0]));
1402
1403                 if (hostdata->madapter_info.port_max_txu[0])
1404                         hostdata->host->max_sectors =
1405                                 be32_to_cpu(hostdata->madapter_info.port_max_txu[0]) >> 9;
1406
1407                 if (be32_to_cpu(hostdata->madapter_info.os_type) == SRP_MAD_OS_AIX &&
1408                     strcmp(hostdata->madapter_info.srp_version, "1.6a") <= 0) {
1409                         dev_err(hostdata->dev, "host (Ver. %s) doesn't support large transfers\n",
1410                                 hostdata->madapter_info.srp_version);
1411                         dev_err(hostdata->dev, "limiting scatterlists to %d\n",
1412                                 MAX_INDIRECT_BUFS);
1413                         hostdata->host->sg_tablesize = MAX_INDIRECT_BUFS;
1414                 }
1415
1416                 if (be32_to_cpu(hostdata->madapter_info.os_type) == SRP_MAD_OS_AIX) {
1417                         enable_fast_fail(hostdata);
1418                         return;
1419                 }
1420         }
1421
1422         send_srp_login(hostdata);
1423 }
1424
1425 /**
1426  * send_mad_adapter_info: - Sends the mad adapter info request
1427  *      and stores the result so it can be retrieved with
1428  *      sysfs.  We COULD consider causing a failure if the
1429  *      returned SRP version doesn't match ours.
1430  * @hostdata:   ibmvscsi_host_data of host
1431  *
1432  * Returns zero if successful.
1433 */
1434 static void send_mad_adapter_info(struct ibmvscsi_host_data *hostdata)
1435 {
1436         struct viosrp_adapter_info *req;
1437         struct srp_event_struct *evt_struct;
1438         unsigned long flags;
1439
1440         evt_struct = get_event_struct(&hostdata->pool);
1441         BUG_ON(!evt_struct);
1442
1443         init_event_struct(evt_struct,
1444                           adapter_info_rsp,
1445                           VIOSRP_MAD_FORMAT,
1446                           info_timeout);
1447
1448         req = &evt_struct->iu.mad.adapter_info;
1449         memset(req, 0x00, sizeof(*req));
1450
1451         req->common.type = cpu_to_be32(VIOSRP_ADAPTER_INFO_TYPE);
1452         req->common.length = cpu_to_be16(sizeof(hostdata->madapter_info));
1453         req->buffer = cpu_to_be64(hostdata->adapter_info_addr);
1454
1455         spin_lock_irqsave(hostdata->host->host_lock, flags);
1456         if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2))
1457                 dev_err(hostdata->dev, "couldn't send ADAPTER_INFO_REQ!\n");
1458         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1459 };
1460
1461 /*
1462  * init_adapter() - Start virtual adapter initialization sequence
1463  */
1464 static void init_adapter(struct ibmvscsi_host_data *hostdata)
1465 {
1466         send_mad_adapter_info(hostdata);
1467 }
1468
1469 /*
1470  * sync_completion: Signal that a synchronous command has completed
1471  * Note that after returning from this call, the evt_struct is freed.
1472  * the caller waiting on this completion shouldn't touch the evt_struct
1473  * again.
1474  */
1475 static void sync_completion(struct srp_event_struct *evt_struct)
1476 {
1477         /* copy the response back */
1478         if (evt_struct->sync_srp)
1479                 *evt_struct->sync_srp = *evt_struct->xfer_iu;
1480
1481         complete(&evt_struct->comp);
1482 }
1483
1484 /*
1485  * ibmvscsi_eh_abort_handler: Abort a command...from scsi host template
1486  * send this over to the server and wait synchronously for the response
1487  */
1488 static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
1489 {
1490         struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1491         struct srp_tsk_mgmt *tsk_mgmt;
1492         struct srp_event_struct *evt;
1493         struct srp_event_struct *tmp_evt, *found_evt;
1494         union viosrp_iu srp_rsp;
1495         int rsp_rc;
1496         unsigned long flags;
1497         u16 lun = lun_from_dev(cmd->device);
1498         unsigned long wait_switch = 0;
1499
1500         /* First, find this command in our sent list so we can figure
1501          * out the correct tag
1502          */
1503         spin_lock_irqsave(hostdata->host->host_lock, flags);
1504         wait_switch = jiffies + (init_timeout * HZ);
1505         do {
1506                 found_evt = NULL;
1507                 list_for_each_entry(tmp_evt, &hostdata->sent, list) {
1508                         if (tmp_evt->cmnd == cmd) {
1509                                 found_evt = tmp_evt;
1510                                 break;
1511                         }
1512                 }
1513
1514                 if (!found_evt) {
1515                         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1516                         return SUCCESS;
1517                 }
1518
1519                 evt = get_event_struct(&hostdata->pool);
1520                 if (evt == NULL) {
1521                         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1522                         sdev_printk(KERN_ERR, cmd->device,
1523                                 "failed to allocate abort event\n");
1524                         return FAILED;
1525                 }
1526
1527                 init_event_struct(evt,
1528                                   sync_completion,
1529                                   VIOSRP_SRP_FORMAT,
1530                                   abort_timeout);
1531
1532                 tsk_mgmt = &evt->iu.srp.tsk_mgmt;
1533
1534                 /* Set up an abort SRP command */
1535                 memset(tsk_mgmt, 0x00, sizeof(*tsk_mgmt));
1536                 tsk_mgmt->opcode = SRP_TSK_MGMT;
1537                 int_to_scsilun(lun, &tsk_mgmt->lun);
1538                 tsk_mgmt->tsk_mgmt_func = SRP_TSK_ABORT_TASK;
1539                 tsk_mgmt->task_tag = (u64) found_evt;
1540
1541                 evt->sync_srp = &srp_rsp;
1542
1543                 init_completion(&evt->comp);
1544                 rsp_rc = ibmvscsi_send_srp_event(evt, hostdata, abort_timeout * 2);
1545
1546                 if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY)
1547                         break;
1548
1549                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1550                 msleep(10);
1551                 spin_lock_irqsave(hostdata->host->host_lock, flags);
1552         } while (time_before(jiffies, wait_switch));
1553
1554         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1555
1556         if (rsp_rc != 0) {
1557                 sdev_printk(KERN_ERR, cmd->device,
1558                             "failed to send abort() event. rc=%d\n", rsp_rc);
1559                 return FAILED;
1560         }
1561
1562         sdev_printk(KERN_INFO, cmd->device,
1563                     "aborting command. lun 0x%llx, tag 0x%llx\n",
1564                     (((u64) lun) << 48), (u64) found_evt);
1565
1566         wait_for_completion(&evt->comp);
1567
1568         /* make sure we got a good response */
1569         if (unlikely(srp_rsp.srp.rsp.opcode != SRP_RSP)) {
1570                 if (printk_ratelimit())
1571                         sdev_printk(KERN_WARNING, cmd->device, "abort bad SRP RSP type %d\n",
1572                                     srp_rsp.srp.rsp.opcode);
1573                 return FAILED;
1574         }
1575
1576         if (srp_rsp.srp.rsp.flags & SRP_RSP_FLAG_RSPVALID)
1577                 rsp_rc = *((int *)srp_rsp.srp.rsp.data);
1578         else
1579                 rsp_rc = srp_rsp.srp.rsp.status;
1580
1581         if (rsp_rc) {
1582                 if (printk_ratelimit())
1583                         sdev_printk(KERN_WARNING, cmd->device,
1584                                     "abort code %d for task tag 0x%llx\n",
1585                                     rsp_rc, tsk_mgmt->task_tag);
1586                 return FAILED;
1587         }
1588
1589         /* Because we dropped the spinlock above, it's possible
1590          * The event is no longer in our list.  Make sure it didn't
1591          * complete while we were aborting
1592          */
1593         spin_lock_irqsave(hostdata->host->host_lock, flags);
1594         found_evt = NULL;
1595         list_for_each_entry(tmp_evt, &hostdata->sent, list) {
1596                 if (tmp_evt->cmnd == cmd) {
1597                         found_evt = tmp_evt;
1598                         break;
1599                 }
1600         }
1601
1602         if (found_evt == NULL) {
1603                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1604                 sdev_printk(KERN_INFO, cmd->device, "aborted task tag 0x%llx completed\n",
1605                             tsk_mgmt->task_tag);
1606                 return SUCCESS;
1607         }
1608
1609         sdev_printk(KERN_INFO, cmd->device, "successfully aborted task tag 0x%llx\n",
1610                     tsk_mgmt->task_tag);
1611
1612         cmd->result = (DID_ABORT << 16);
1613         list_del(&found_evt->list);
1614         unmap_cmd_data(&found_evt->iu.srp.cmd, found_evt,
1615                        found_evt->hostdata->dev);
1616         free_event_struct(&found_evt->hostdata->pool, found_evt);
1617         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1618         atomic_inc(&hostdata->request_limit);
1619         return SUCCESS;
1620 }
1621
1622 /*
1623  * ibmvscsi_eh_device_reset_handler: Reset a single LUN...from scsi host
1624  * template send this over to the server and wait synchronously for the
1625  * response
1626  */
1627 static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
1628 {
1629         struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1630         struct srp_tsk_mgmt *tsk_mgmt;
1631         struct srp_event_struct *evt;
1632         struct srp_event_struct *tmp_evt, *pos;
1633         union viosrp_iu srp_rsp;
1634         int rsp_rc;
1635         unsigned long flags;
1636         u16 lun = lun_from_dev(cmd->device);
1637         unsigned long wait_switch = 0;
1638
1639         spin_lock_irqsave(hostdata->host->host_lock, flags);
1640         wait_switch = jiffies + (init_timeout * HZ);
1641         do {
1642                 evt = get_event_struct(&hostdata->pool);
1643                 if (evt == NULL) {
1644                         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1645                         sdev_printk(KERN_ERR, cmd->device,
1646                                 "failed to allocate reset event\n");
1647                         return FAILED;
1648                 }
1649
1650                 init_event_struct(evt,
1651                                   sync_completion,
1652                                   VIOSRP_SRP_FORMAT,
1653                                   reset_timeout);
1654
1655                 tsk_mgmt = &evt->iu.srp.tsk_mgmt;
1656
1657                 /* Set up a lun reset SRP command */
1658                 memset(tsk_mgmt, 0x00, sizeof(*tsk_mgmt));
1659                 tsk_mgmt->opcode = SRP_TSK_MGMT;
1660                 int_to_scsilun(lun, &tsk_mgmt->lun);
1661                 tsk_mgmt->tsk_mgmt_func = SRP_TSK_LUN_RESET;
1662
1663                 evt->sync_srp = &srp_rsp;
1664
1665                 init_completion(&evt->comp);
1666                 rsp_rc = ibmvscsi_send_srp_event(evt, hostdata, reset_timeout * 2);
1667
1668                 if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY)
1669                         break;
1670
1671                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1672                 msleep(10);
1673                 spin_lock_irqsave(hostdata->host->host_lock, flags);
1674         } while (time_before(jiffies, wait_switch));
1675
1676         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1677
1678         if (rsp_rc != 0) {
1679                 sdev_printk(KERN_ERR, cmd->device,
1680                             "failed to send reset event. rc=%d\n", rsp_rc);
1681                 return FAILED;
1682         }
1683
1684         sdev_printk(KERN_INFO, cmd->device, "resetting device. lun 0x%llx\n",
1685                     (((u64) lun) << 48));
1686
1687         wait_for_completion(&evt->comp);
1688
1689         /* make sure we got a good response */
1690         if (unlikely(srp_rsp.srp.rsp.opcode != SRP_RSP)) {
1691                 if (printk_ratelimit())
1692                         sdev_printk(KERN_WARNING, cmd->device, "reset bad SRP RSP type %d\n",
1693                                     srp_rsp.srp.rsp.opcode);
1694                 return FAILED;
1695         }
1696
1697         if (srp_rsp.srp.rsp.flags & SRP_RSP_FLAG_RSPVALID)
1698                 rsp_rc = *((int *)srp_rsp.srp.rsp.data);
1699         else
1700                 rsp_rc = srp_rsp.srp.rsp.status;
1701
1702         if (rsp_rc) {
1703                 if (printk_ratelimit())
1704                         sdev_printk(KERN_WARNING, cmd->device,
1705                                     "reset code %d for task tag 0x%llx\n",
1706                                     rsp_rc, tsk_mgmt->task_tag);
1707                 return FAILED;
1708         }
1709
1710         /* We need to find all commands for this LUN that have not yet been
1711          * responded to, and fail them with DID_RESET
1712          */
1713         spin_lock_irqsave(hostdata->host->host_lock, flags);
1714         list_for_each_entry_safe(tmp_evt, pos, &hostdata->sent, list) {
1715                 if ((tmp_evt->cmnd) && (tmp_evt->cmnd->device == cmd->device)) {
1716                         if (tmp_evt->cmnd)
1717                                 tmp_evt->cmnd->result = (DID_RESET << 16);
1718                         list_del(&tmp_evt->list);
1719                         unmap_cmd_data(&tmp_evt->iu.srp.cmd, tmp_evt,
1720                                        tmp_evt->hostdata->dev);
1721                         free_event_struct(&tmp_evt->hostdata->pool,
1722                                                    tmp_evt);
1723                         atomic_inc(&hostdata->request_limit);
1724                         if (tmp_evt->cmnd_done)
1725                                 tmp_evt->cmnd_done(tmp_evt->cmnd);
1726                         else if (tmp_evt->done)
1727                                 tmp_evt->done(tmp_evt);
1728                 }
1729         }
1730         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1731         return SUCCESS;
1732 }
1733
1734 /**
1735  * ibmvscsi_eh_host_reset_handler - Reset the connection to the server
1736  * @cmd:        struct scsi_cmnd having problems
1737 */
1738 static int ibmvscsi_eh_host_reset_handler(struct scsi_cmnd *cmd)
1739 {
1740         unsigned long wait_switch = 0;
1741         struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1742
1743         dev_err(hostdata->dev, "Resetting connection due to error recovery\n");
1744
1745         ibmvscsi_reset_host(hostdata);
1746
1747         for (wait_switch = jiffies + (init_timeout * HZ);
1748              time_before(jiffies, wait_switch) &&
1749                      atomic_read(&hostdata->request_limit) < 2;) {
1750
1751                 msleep(10);
1752         }
1753
1754         if (atomic_read(&hostdata->request_limit) <= 0)
1755                 return FAILED;
1756
1757         return SUCCESS;
1758 }
1759
1760 /**
1761  * ibmvscsi_handle_crq: - Handles and frees received events in the CRQ
1762  * @crq:        Command/Response queue
1763  * @hostdata:   ibmvscsi_host_data of host
1764  *
1765 */
1766 static void ibmvscsi_handle_crq(struct viosrp_crq *crq,
1767                                 struct ibmvscsi_host_data *hostdata)
1768 {
1769         long rc;
1770         unsigned long flags;
1771         /* The hypervisor copies our tag value here so no byteswapping */
1772         struct srp_event_struct *evt_struct =
1773                         (__force struct srp_event_struct *)crq->IU_data_ptr;
1774         switch (crq->valid) {
1775         case VIOSRP_CRQ_INIT_RSP:               /* initialization */
1776                 switch (crq->format) {
1777                 case VIOSRP_CRQ_INIT:   /* Initialization message */
1778                         dev_info(hostdata->dev, "partner initialized\n");
1779                         /* Send back a response */
1780                         rc = ibmvscsi_send_crq(hostdata, 0xC002000000000000LL, 0);
1781                         if (rc == 0) {
1782                                 /* Now login */
1783                                 init_adapter(hostdata);
1784                         } else {
1785                                 dev_err(hostdata->dev, "Unable to send init rsp. rc=%ld\n", rc);
1786                         }
1787
1788                         break;
1789                 case VIOSRP_CRQ_INIT_COMPLETE:  /* Initialization response */
1790                         dev_info(hostdata->dev, "partner initialization complete\n");
1791
1792                         /* Now login */
1793                         init_adapter(hostdata);
1794                         break;
1795                 default:
1796                         dev_err(hostdata->dev, "unknown crq message type: %d\n", crq->format);
1797                 }
1798                 return;
1799         case VIOSRP_CRQ_XPORT_EVENT:    /* Hypervisor telling us the connection is closed */
1800                 scsi_block_requests(hostdata->host);
1801                 ibmvscsi_set_request_limit(hostdata, 0);
1802                 if (crq->format == 0x06) {
1803                         /* We need to re-setup the interpartition connection */
1804                         dev_info(hostdata->dev, "Re-enabling adapter!\n");
1805                         hostdata->client_migrated = 1;
1806                         hostdata->action = IBMVSCSI_HOST_ACTION_REENABLE;
1807                         purge_requests(hostdata, DID_REQUEUE);
1808                         wake_up(&hostdata->work_wait_q);
1809                 } else {
1810                         dev_err(hostdata->dev, "Virtual adapter failed rc %d!\n",
1811                                 crq->format);
1812                         ibmvscsi_reset_host(hostdata);
1813                 }
1814                 return;
1815         case VIOSRP_CRQ_CMD_RSP:                /* real payload */
1816                 break;
1817         default:
1818                 dev_err(hostdata->dev, "got an invalid message type 0x%02x\n",
1819                         crq->valid);
1820                 return;
1821         }
1822
1823         /* The only kind of payload CRQs we should get are responses to
1824          * things we send. Make sure this response is to something we
1825          * actually sent
1826          */
1827         if (!valid_event_struct(&hostdata->pool, evt_struct)) {
1828                 dev_err(hostdata->dev, "returned correlation_token 0x%p is invalid!\n",
1829                        evt_struct);
1830                 return;
1831         }
1832
1833         if (atomic_read(&evt_struct->free)) {
1834                 dev_err(hostdata->dev, "received duplicate correlation_token 0x%p!\n",
1835                         evt_struct);
1836                 return;
1837         }
1838
1839         if (crq->format == VIOSRP_SRP_FORMAT)
1840                 atomic_add(be32_to_cpu(evt_struct->xfer_iu->srp.rsp.req_lim_delta),
1841                            &hostdata->request_limit);
1842
1843         del_timer(&evt_struct->timer);
1844
1845         if ((crq->status != VIOSRP_OK && crq->status != VIOSRP_OK2) && evt_struct->cmnd)
1846                 evt_struct->cmnd->result = DID_ERROR << 16;
1847         if (evt_struct->done)
1848                 evt_struct->done(evt_struct);
1849         else
1850                 dev_err(hostdata->dev, "returned done() is NULL; not running it!\n");
1851
1852         /*
1853          * Lock the host_lock before messing with these structures, since we
1854          * are running in a task context
1855          */
1856         spin_lock_irqsave(evt_struct->hostdata->host->host_lock, flags);
1857         list_del(&evt_struct->list);
1858         free_event_struct(&evt_struct->hostdata->pool, evt_struct);
1859         spin_unlock_irqrestore(evt_struct->hostdata->host->host_lock, flags);
1860 }
1861
1862 /**
1863  * ibmvscsi_slave_configure: Set the "allow_restart" flag for each disk.
1864  * @sdev:       struct scsi_device device to configure
1865  *
1866  * Enable allow_restart for a device if it is a disk.  Adjust the
1867  * queue_depth here also as is required by the documentation for
1868  * struct scsi_host_template.
1869  */
1870 static int ibmvscsi_slave_configure(struct scsi_device *sdev)
1871 {
1872         struct Scsi_Host *shost = sdev->host;
1873         unsigned long lock_flags = 0;
1874
1875         spin_lock_irqsave(shost->host_lock, lock_flags);
1876         if (sdev->type == TYPE_DISK) {
1877                 sdev->allow_restart = 1;
1878                 blk_queue_rq_timeout(sdev->request_queue, 120 * HZ);
1879         }
1880         spin_unlock_irqrestore(shost->host_lock, lock_flags);
1881         return 0;
1882 }
1883
1884 /**
1885  * ibmvscsi_change_queue_depth - Change the device's queue depth
1886  * @sdev:       scsi device struct
1887  * @qdepth:     depth to set
1888  *
1889  * Return value:
1890  *      actual depth set
1891  **/
1892 static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
1893 {
1894         if (qdepth > IBMVSCSI_MAX_CMDS_PER_LUN)
1895                 qdepth = IBMVSCSI_MAX_CMDS_PER_LUN;
1896         return scsi_change_queue_depth(sdev, qdepth);
1897 }
1898
1899 /* ------------------------------------------------------------
1900  * sysfs attributes
1901  */
1902 static ssize_t show_host_vhost_loc(struct device *dev,
1903                                    struct device_attribute *attr, char *buf)
1904 {
1905         struct Scsi_Host *shost = class_to_shost(dev);
1906         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1907         int len;
1908
1909         len = snprintf(buf, sizeof(hostdata->caps.loc), "%s\n",
1910                        hostdata->caps.loc);
1911         return len;
1912 }
1913
1914 static struct device_attribute ibmvscsi_host_vhost_loc = {
1915         .attr = {
1916                  .name = "vhost_loc",
1917                  .mode = S_IRUGO,
1918                  },
1919         .show = show_host_vhost_loc,
1920 };
1921
1922 static ssize_t show_host_vhost_name(struct device *dev,
1923                                     struct device_attribute *attr, char *buf)
1924 {
1925         struct Scsi_Host *shost = class_to_shost(dev);
1926         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1927         int len;
1928
1929         len = snprintf(buf, sizeof(hostdata->caps.name), "%s\n",
1930                        hostdata->caps.name);
1931         return len;
1932 }
1933
1934 static struct device_attribute ibmvscsi_host_vhost_name = {
1935         .attr = {
1936                  .name = "vhost_name",
1937                  .mode = S_IRUGO,
1938                  },
1939         .show = show_host_vhost_name,
1940 };
1941
1942 static ssize_t show_host_srp_version(struct device *dev,
1943                                      struct device_attribute *attr, char *buf)
1944 {
1945         struct Scsi_Host *shost = class_to_shost(dev);
1946         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1947         int len;
1948
1949         len = snprintf(buf, PAGE_SIZE, "%s\n",
1950                        hostdata->madapter_info.srp_version);
1951         return len;
1952 }
1953
1954 static struct device_attribute ibmvscsi_host_srp_version = {
1955         .attr = {
1956                  .name = "srp_version",
1957                  .mode = S_IRUGO,
1958                  },
1959         .show = show_host_srp_version,
1960 };
1961
1962 static ssize_t show_host_partition_name(struct device *dev,
1963                                         struct device_attribute *attr,
1964                                         char *buf)
1965 {
1966         struct Scsi_Host *shost = class_to_shost(dev);
1967         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1968         int len;
1969
1970         len = snprintf(buf, PAGE_SIZE, "%s\n",
1971                        hostdata->madapter_info.partition_name);
1972         return len;
1973 }
1974
1975 static struct device_attribute ibmvscsi_host_partition_name = {
1976         .attr = {
1977                  .name = "partition_name",
1978                  .mode = S_IRUGO,
1979                  },
1980         .show = show_host_partition_name,
1981 };
1982
1983 static ssize_t show_host_partition_number(struct device *dev,
1984                                           struct device_attribute *attr,
1985                                           char *buf)
1986 {
1987         struct Scsi_Host *shost = class_to_shost(dev);
1988         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
1989         int len;
1990
1991         len = snprintf(buf, PAGE_SIZE, "%d\n",
1992                        be32_to_cpu(hostdata->madapter_info.partition_number));
1993         return len;
1994 }
1995
1996 static struct device_attribute ibmvscsi_host_partition_number = {
1997         .attr = {
1998                  .name = "partition_number",
1999                  .mode = S_IRUGO,
2000                  },
2001         .show = show_host_partition_number,
2002 };
2003
2004 static ssize_t show_host_mad_version(struct device *dev,
2005                                      struct device_attribute *attr, char *buf)
2006 {
2007         struct Scsi_Host *shost = class_to_shost(dev);
2008         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2009         int len;
2010
2011         len = snprintf(buf, PAGE_SIZE, "%d\n",
2012                        be32_to_cpu(hostdata->madapter_info.mad_version));
2013         return len;
2014 }
2015
2016 static struct device_attribute ibmvscsi_host_mad_version = {
2017         .attr = {
2018                  .name = "mad_version",
2019                  .mode = S_IRUGO,
2020                  },
2021         .show = show_host_mad_version,
2022 };
2023
2024 static ssize_t show_host_os_type(struct device *dev,
2025                                  struct device_attribute *attr, char *buf)
2026 {
2027         struct Scsi_Host *shost = class_to_shost(dev);
2028         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2029         int len;
2030
2031         len = snprintf(buf, PAGE_SIZE, "%d\n",
2032                        be32_to_cpu(hostdata->madapter_info.os_type));
2033         return len;
2034 }
2035
2036 static struct device_attribute ibmvscsi_host_os_type = {
2037         .attr = {
2038                  .name = "os_type",
2039                  .mode = S_IRUGO,
2040                  },
2041         .show = show_host_os_type,
2042 };
2043
2044 static ssize_t show_host_config(struct device *dev,
2045                                 struct device_attribute *attr, char *buf)
2046 {
2047         return 0;
2048 }
2049
2050 static struct device_attribute ibmvscsi_host_config = {
2051         .attr = {
2052                 .name = "config",
2053                 .mode = S_IRUGO,
2054                 },
2055         .show = show_host_config,
2056 };
2057
2058 static int ibmvscsi_host_reset(struct Scsi_Host *shost, int reset_type)
2059 {
2060         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
2061
2062         dev_info(hostdata->dev, "Initiating adapter reset!\n");
2063         ibmvscsi_reset_host(hostdata);
2064
2065         return 0;
2066 }
2067
2068 static struct attribute *ibmvscsi_host_attrs[] = {
2069         &ibmvscsi_host_vhost_loc.attr,
2070         &ibmvscsi_host_vhost_name.attr,
2071         &ibmvscsi_host_srp_version.attr,
2072         &ibmvscsi_host_partition_name.attr,
2073         &ibmvscsi_host_partition_number.attr,
2074         &ibmvscsi_host_mad_version.attr,
2075         &ibmvscsi_host_os_type.attr,
2076         &ibmvscsi_host_config.attr,
2077         NULL
2078 };
2079
2080 ATTRIBUTE_GROUPS(ibmvscsi_host);
2081
2082 /* ------------------------------------------------------------
2083  * SCSI driver registration
2084  */
2085 static struct scsi_host_template driver_template = {
2086         .module = THIS_MODULE,
2087         .name = "IBM POWER Virtual SCSI Adapter " IBMVSCSI_VERSION,
2088         .proc_name = "ibmvscsi",
2089         .queuecommand = ibmvscsi_queuecommand,
2090         .eh_timed_out = srp_timed_out,
2091         .eh_abort_handler = ibmvscsi_eh_abort_handler,
2092         .eh_device_reset_handler = ibmvscsi_eh_device_reset_handler,
2093         .eh_host_reset_handler = ibmvscsi_eh_host_reset_handler,
2094         .slave_configure = ibmvscsi_slave_configure,
2095         .change_queue_depth = ibmvscsi_change_queue_depth,
2096         .host_reset = ibmvscsi_host_reset,
2097         .cmd_per_lun = IBMVSCSI_CMDS_PER_LUN_DEFAULT,
2098         .can_queue = IBMVSCSI_MAX_REQUESTS_DEFAULT,
2099         .this_id = -1,
2100         .sg_tablesize = SG_ALL,
2101         .shost_groups = ibmvscsi_host_groups,
2102 };
2103
2104 /**
2105  * ibmvscsi_get_desired_dma - Calculate IO memory desired by the driver
2106  *
2107  * @vdev: struct vio_dev for the device whose desired IO mem is to be returned
2108  *
2109  * Return value:
2110  *      Number of bytes of IO data the driver will need to perform well.
2111  */
2112 static unsigned long ibmvscsi_get_desired_dma(struct vio_dev *vdev)
2113 {
2114         /* iu_storage data allocated in initialize_event_pool */
2115         unsigned long desired_io = max_events * sizeof(union viosrp_iu);
2116
2117         /* add io space for sg data */
2118         desired_io += (IBMVSCSI_MAX_SECTORS_DEFAULT * 512 *
2119                              IBMVSCSI_CMDS_PER_LUN_DEFAULT);
2120
2121         return desired_io;
2122 }
2123
2124 static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata)
2125 {
2126         unsigned long flags;
2127         int rc;
2128         char *action = "reset";
2129
2130         spin_lock_irqsave(hostdata->host->host_lock, flags);
2131         switch (hostdata->action) {
2132         case IBMVSCSI_HOST_ACTION_UNBLOCK:
2133                 rc = 0;
2134                 break;
2135         case IBMVSCSI_HOST_ACTION_RESET:
2136                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2137                 rc = ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata);
2138                 spin_lock_irqsave(hostdata->host->host_lock, flags);
2139                 if (!rc)
2140                         rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
2141                 vio_enable_interrupts(to_vio_dev(hostdata->dev));
2142                 break;
2143         case IBMVSCSI_HOST_ACTION_REENABLE:
2144                 action = "enable";
2145                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2146                 rc = ibmvscsi_reenable_crq_queue(&hostdata->queue, hostdata);
2147                 spin_lock_irqsave(hostdata->host->host_lock, flags);
2148                 if (!rc)
2149                         rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
2150                 break;
2151         case IBMVSCSI_HOST_ACTION_NONE:
2152         default:
2153                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2154                 return;
2155         }
2156
2157         hostdata->action = IBMVSCSI_HOST_ACTION_NONE;
2158         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2159
2160         if (rc) {
2161                 ibmvscsi_set_request_limit(hostdata, -1);
2162                 dev_err(hostdata->dev, "error after %s\n", action);
2163         }
2164
2165         scsi_unblock_requests(hostdata->host);
2166 }
2167
2168 static int __ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata)
2169 {
2170         if (kthread_should_stop())
2171                 return 1;
2172         switch (hostdata->action) {
2173         case IBMVSCSI_HOST_ACTION_NONE:
2174                 return 0;
2175         case IBMVSCSI_HOST_ACTION_RESET:
2176         case IBMVSCSI_HOST_ACTION_REENABLE:
2177         case IBMVSCSI_HOST_ACTION_UNBLOCK:
2178         default:
2179                 break;
2180         }
2181
2182         return 1;
2183 }
2184
2185 static int ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata)
2186 {
2187         unsigned long flags;
2188         int rc;
2189
2190         spin_lock_irqsave(hostdata->host->host_lock, flags);
2191         rc = __ibmvscsi_work_to_do(hostdata);
2192         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2193
2194         return rc;
2195 }
2196
2197 static int ibmvscsi_work(void *data)
2198 {
2199         struct ibmvscsi_host_data *hostdata = data;
2200         int rc;
2201
2202         set_user_nice(current, MIN_NICE);
2203
2204         while (1) {
2205                 rc = wait_event_interruptible(hostdata->work_wait_q,
2206                                               ibmvscsi_work_to_do(hostdata));
2207
2208                 BUG_ON(rc);
2209
2210                 if (kthread_should_stop())
2211                         break;
2212
2213                 ibmvscsi_do_work(hostdata);
2214         }
2215
2216         return 0;
2217 }
2218
2219 /*
2220  * Called by bus code for each adapter
2221  */
2222 static int ibmvscsi_probe(struct vio_dev *vdev, const struct vio_device_id *id)
2223 {
2224         struct ibmvscsi_host_data *hostdata;
2225         struct Scsi_Host *host;
2226         struct device *dev = &vdev->dev;
2227         struct srp_rport_identifiers ids;
2228         struct srp_rport *rport;
2229         unsigned long wait_switch = 0;
2230         int rc;
2231
2232         dev_set_drvdata(&vdev->dev, NULL);
2233
2234         host = scsi_host_alloc(&driver_template, sizeof(*hostdata));
2235         if (!host) {
2236                 dev_err(&vdev->dev, "couldn't allocate host data\n");
2237                 goto scsi_host_alloc_failed;
2238         }
2239
2240         host->transportt = ibmvscsi_transport_template;
2241         hostdata = shost_priv(host);
2242         memset(hostdata, 0x00, sizeof(*hostdata));
2243         INIT_LIST_HEAD(&hostdata->sent);
2244         init_waitqueue_head(&hostdata->work_wait_q);
2245         hostdata->host = host;
2246         hostdata->dev = dev;
2247         ibmvscsi_set_request_limit(hostdata, -1);
2248         hostdata->host->max_sectors = IBMVSCSI_MAX_SECTORS_DEFAULT;
2249
2250         if (map_persist_bufs(hostdata)) {
2251                 dev_err(&vdev->dev, "couldn't map persistent buffers\n");
2252                 goto persist_bufs_failed;
2253         }
2254
2255         hostdata->work_thread = kthread_run(ibmvscsi_work, hostdata, "%s_%d",
2256                                             "ibmvscsi", host->host_no);
2257
2258         if (IS_ERR(hostdata->work_thread)) {
2259                 dev_err(&vdev->dev, "couldn't initialize kthread. rc=%ld\n",
2260                         PTR_ERR(hostdata->work_thread));
2261                 goto init_crq_failed;
2262         }
2263
2264         rc = ibmvscsi_init_crq_queue(&hostdata->queue, hostdata, max_events);
2265         if (rc != 0 && rc != H_RESOURCE) {
2266                 dev_err(&vdev->dev, "couldn't initialize crq. rc=%d\n", rc);
2267                 goto kill_kthread;
2268         }
2269         if (initialize_event_pool(&hostdata->pool, max_events, hostdata) != 0) {
2270                 dev_err(&vdev->dev, "couldn't initialize event pool\n");
2271                 goto init_pool_failed;
2272         }
2273
2274         host->max_lun = IBMVSCSI_MAX_LUN;
2275         host->max_id = max_id;
2276         host->max_channel = max_channel;
2277         host->max_cmd_len = 16;
2278
2279         dev_info(dev,
2280                  "Maximum ID: %d Maximum LUN: %llu Maximum Channel: %d\n",
2281                  host->max_id, host->max_lun, host->max_channel);
2282
2283         if (scsi_add_host(hostdata->host, hostdata->dev))
2284                 goto add_host_failed;
2285
2286         /* we don't have a proper target_port_id so let's use the fake one */
2287         memcpy(ids.port_id, hostdata->madapter_info.partition_name,
2288                sizeof(ids.port_id));
2289         ids.roles = SRP_RPORT_ROLE_TARGET;
2290         rport = srp_rport_add(host, &ids);
2291         if (IS_ERR(rport))
2292                 goto add_srp_port_failed;
2293
2294         /* Try to send an initialization message.  Note that this is allowed
2295          * to fail if the other end is not acive.  In that case we don't
2296          * want to scan
2297          */
2298         if (ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0) == 0
2299             || rc == H_RESOURCE) {
2300                 /*
2301                  * Wait around max init_timeout secs for the adapter to finish
2302                  * initializing. When we are done initializing, we will have a
2303                  * valid request_limit.  We don't want Linux scanning before
2304                  * we are ready.
2305                  */
2306                 for (wait_switch = jiffies + (init_timeout * HZ);
2307                      time_before(jiffies, wait_switch) &&
2308                      atomic_read(&hostdata->request_limit) < 2;) {
2309
2310                         msleep(10);
2311                 }
2312
2313                 /* if we now have a valid request_limit, initiate a scan */
2314                 if (atomic_read(&hostdata->request_limit) > 0)
2315                         scsi_scan_host(host);
2316         }
2317
2318         dev_set_drvdata(&vdev->dev, hostdata);
2319         spin_lock(&ibmvscsi_driver_lock);
2320         list_add_tail(&hostdata->host_list, &ibmvscsi_head);
2321         spin_unlock(&ibmvscsi_driver_lock);
2322         return 0;
2323
2324       add_srp_port_failed:
2325         scsi_remove_host(hostdata->host);
2326       add_host_failed:
2327         release_event_pool(&hostdata->pool, hostdata);
2328       init_pool_failed:
2329         ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, max_events);
2330       kill_kthread:
2331       kthread_stop(hostdata->work_thread);
2332       init_crq_failed:
2333         unmap_persist_bufs(hostdata);
2334       persist_bufs_failed:
2335         scsi_host_put(host);
2336       scsi_host_alloc_failed:
2337         return -1;
2338 }
2339
2340 static void ibmvscsi_remove(struct vio_dev *vdev)
2341 {
2342         struct ibmvscsi_host_data *hostdata = dev_get_drvdata(&vdev->dev);
2343
2344         srp_remove_host(hostdata->host);
2345         scsi_remove_host(hostdata->host);
2346
2347         purge_requests(hostdata, DID_ERROR);
2348         release_event_pool(&hostdata->pool, hostdata);
2349
2350         ibmvscsi_release_crq_queue(&hostdata->queue, hostdata,
2351                                         max_events);
2352
2353         kthread_stop(hostdata->work_thread);
2354         unmap_persist_bufs(hostdata);
2355
2356         spin_lock(&ibmvscsi_driver_lock);
2357         list_del(&hostdata->host_list);
2358         spin_unlock(&ibmvscsi_driver_lock);
2359
2360         scsi_host_put(hostdata->host);
2361 }
2362
2363 /**
2364  * ibmvscsi_resume: Resume from suspend
2365  * @dev:        device struct
2366  *
2367  * We may have lost an interrupt across suspend/resume, so kick the
2368  * interrupt handler
2369  */
2370 static int ibmvscsi_resume(struct device *dev)
2371 {
2372         struct ibmvscsi_host_data *hostdata = dev_get_drvdata(dev);
2373         vio_disable_interrupts(to_vio_dev(hostdata->dev));
2374         tasklet_schedule(&hostdata->srp_task);
2375
2376         return 0;
2377 }
2378
2379 /*
2380  * ibmvscsi_device_table: Used by vio.c to match devices in the device tree we
2381  * support.
2382  */
2383 static const struct vio_device_id ibmvscsi_device_table[] = {
2384         {"vscsi", "IBM,v-scsi"},
2385         { "", "" }
2386 };
2387 MODULE_DEVICE_TABLE(vio, ibmvscsi_device_table);
2388
2389 static const struct dev_pm_ops ibmvscsi_pm_ops = {
2390         .resume = ibmvscsi_resume
2391 };
2392
2393 static struct vio_driver ibmvscsi_driver = {
2394         .id_table = ibmvscsi_device_table,
2395         .probe = ibmvscsi_probe,
2396         .remove = ibmvscsi_remove,
2397         .get_desired_dma = ibmvscsi_get_desired_dma,
2398         .name = "ibmvscsi",
2399         .pm = &ibmvscsi_pm_ops,
2400 };
2401
2402 static struct srp_function_template ibmvscsi_transport_functions = {
2403 };
2404
2405 static int __init ibmvscsi_module_init(void)
2406 {
2407         int ret;
2408
2409         /* Ensure we have two requests to do error recovery */
2410         driver_template.can_queue = max_requests;
2411         max_events = max_requests + 2;
2412
2413         if (!firmware_has_feature(FW_FEATURE_VIO))
2414                 return -ENODEV;
2415
2416         ibmvscsi_transport_template =
2417                 srp_attach_transport(&ibmvscsi_transport_functions);
2418         if (!ibmvscsi_transport_template)
2419                 return -ENOMEM;
2420
2421         ret = vio_register_driver(&ibmvscsi_driver);
2422         if (ret)
2423                 srp_release_transport(ibmvscsi_transport_template);
2424         return ret;
2425 }
2426
2427 static void __exit ibmvscsi_module_exit(void)
2428 {
2429         vio_unregister_driver(&ibmvscsi_driver);
2430         srp_release_transport(ibmvscsi_transport_template);
2431 }
2432
2433 module_init(ibmvscsi_module_init);
2434 module_exit(ibmvscsi_module_exit);