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  * release_crq_queue: - Deallocates data and unregisters CRQ
 134  * @queue:      crq_queue to initialize and register
 135  * @host_data:  ibmvscsi_host_data of host
 136  *
 137  * Frees irq, deallocates a page for messages, unmaps dma, and unregisters
 138  * the crq with the hypervisor.
 139  */
 140 static void ibmvscsi_release_crq_queue(struct crq_queue *queue,
 141                                        struct ibmvscsi_host_data *hostdata,
 142                                        int max_requests)
 143 {
 144         long rc = 0;
 145         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 146         free_irq(vdev->irq, (void *)hostdata);
 147         tasklet_kill(&hostdata->srp_task);
 148         do {
 149                 if (rc)
 150                         msleep(100);
 151                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
 152         } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
 153         dma_unmap_single(hostdata->dev,
 154                          queue->msg_token,
 155                          queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
 156         free_page((unsigned long)queue->msgs);
 157 }
 158
 159 /**
 160  * crq_queue_next_crq: - Returns the next entry in message queue
 161  * @queue:      crq_queue to use
 162  *
 163  * Returns pointer to next entry in queue, or NULL if there are no new
 164  * entried in the CRQ.
 165  */
 166 static struct viosrp_crq *crq_queue_next_crq(struct crq_queue *queue)
 167 {
 168         struct viosrp_crq *crq;
 169         unsigned long flags;
 170
 171         spin_lock_irqsave(&queue->lock, flags);
 172         crq = &queue->msgs[queue->cur];
 173         if (crq->valid != VIOSRP_CRQ_FREE) {
 174                 if (++queue->cur == queue->size)
 175                         queue->cur = 0;
 176
 177                 /* Ensure the read of the valid bit occurs before reading any
 178                  * other bits of the CRQ entry
 179                  */
 180                 rmb();
 181         } else
 182                 crq = NULL;
 183         spin_unlock_irqrestore(&queue->lock, flags);
 184
 185         return crq;
 186 }
 187
 188 /**
 189  * ibmvscsi_send_crq: - Send a CRQ
 190  * @hostdata:   the adapter
 191  * @word1:      the first 64 bits of the data
 192  * @word2:      the second 64 bits of the data
 193  */
 194 static int ibmvscsi_send_crq(struct ibmvscsi_host_data *hostdata,
 195                              u64 word1, u64 word2)
 196 {
 197         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 198
 199         /*
 200          * Ensure the command buffer is flushed to memory before handing it
 201          * over to the VIOS to prevent it from fetching any stale data.
 202          */
 203         mb();
 204         return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
 205 }
 206
 207 /**
 208  * ibmvscsi_task: - Process srps asynchronously
 209  * @data:       ibmvscsi_host_data of host
 210  */
 211 static void ibmvscsi_task(void *data)
 212 {
 213         struct ibmvscsi_host_data *hostdata = (struct ibmvscsi_host_data *)data;
 214         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 215         struct viosrp_crq *crq;
 216         int done = 0;
 217
 218         while (!done) {
 219                 /* Pull all the valid messages off the CRQ */
 220                 while ((crq = crq_queue_next_crq(&hostdata->queue)) != NULL) {
 221                         ibmvscsi_handle_crq(crq, hostdata);
 222                         crq->valid = VIOSRP_CRQ_FREE;
 223                         wmb();
 224                 }
 225
 226                 vio_enable_interrupts(vdev);
 227                 crq = crq_queue_next_crq(&hostdata->queue);
 228                 if (crq != NULL) {
 229                         vio_disable_interrupts(vdev);
 230                         ibmvscsi_handle_crq(crq, hostdata);
 231                         crq->valid = VIOSRP_CRQ_FREE;
 232                         wmb();
 233                 } else {
 234                         done = 1;
 235                 }
 236         }
 237 }
 238
 239 static void gather_partition_info(void)
 240 {
 241         const char *ppartition_name;
 242         const __be32 *p_number_ptr;
 243
 244         /* Retrieve information about this partition */
 245         if (!of_root)
 246                 return;
 247
 248         of_node_get(of_root);
 249
 250         ppartition_name = of_get_property(of_root, "ibm,partition-name", NULL);
 251         if (ppartition_name)
 252                 strlcpy(partition_name, ppartition_name,
 253                                 sizeof(partition_name));
 254         p_number_ptr = of_get_property(of_root, "ibm,partition-no", NULL);
 255         if (p_number_ptr)
 256                 partition_number = of_read_number(p_number_ptr, 1);
 257         of_node_put(of_root);
 258 }
 259
 260 static void set_adapter_info(struct ibmvscsi_host_data *hostdata)
 261 {
 262         memset(&hostdata->madapter_info, 0x00,
 263                         sizeof(hostdata->madapter_info));
 264
 265         dev_info(hostdata->dev, "SRP_VERSION: %s\n", SRP_VERSION);
 266         strcpy(hostdata->madapter_info.srp_version, SRP_VERSION);
 267
 268         strncpy(hostdata->madapter_info.partition_name, partition_name,
 269                         sizeof(hostdata->madapter_info.partition_name));
 270
 271         hostdata->madapter_info.partition_number =
 272                                         cpu_to_be32(partition_number);
 273
 274         hostdata->madapter_info.mad_version = cpu_to_be32(SRP_MAD_VERSION_1);
 275         hostdata->madapter_info.os_type = cpu_to_be32(SRP_MAD_OS_LINUX);
 276 }
 277
 278 /**
 279  * reset_crq_queue: - resets a crq after a failure
 280  * @queue:      crq_queue to initialize and register
 281  * @hostdata:   ibmvscsi_host_data of host
 282  *
 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  * initialize_crq_queue: - Initializes and registers CRQ with hypervisor
 318  * @queue:      crq_queue to initialize and register
 319  * @hostdata:   ibmvscsi_host_data of host
 320  *
 321  * Allocates a page for messages, maps it for dma, and registers
 322  * the crq with the hypervisor.
 323  * Returns zero on success.
 324  */
 325 static int ibmvscsi_init_crq_queue(struct crq_queue *queue,
 326                                    struct ibmvscsi_host_data *hostdata,
 327                                    int max_requests)
 328 {
 329         int rc;
 330         int retrc;
 331         struct vio_dev *vdev = to_vio_dev(hostdata->dev);
 332
 333         queue->msgs = (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL);
 334
 335         if (!queue->msgs)
 336                 goto malloc_failed;
 337         queue->size = PAGE_SIZE / sizeof(*queue->msgs);
 338
 339         queue->msg_token = dma_map_single(hostdata->dev, queue->msgs,
 340                                           queue->size * sizeof(*queue->msgs),
 341                                           DMA_BIDIRECTIONAL);
 342
 343         if (dma_mapping_error(hostdata->dev, queue->msg_token))
 344                 goto map_failed;
 345
 346         gather_partition_info();
 347         set_adapter_info(hostdata);
 348
 349         retrc = rc = plpar_hcall_norets(H_REG_CRQ,
 350                                 vdev->unit_address,
 351                                 queue->msg_token, PAGE_SIZE);
 352         if (rc == H_RESOURCE)
 353                 /* maybe kexecing and resource is busy. try a reset */
 354                 rc = ibmvscsi_reset_crq_queue(queue,
 355                                               hostdata);
 356
 357         if (rc == H_CLOSED) {
 358                 /* Adapter is good, but other end is not ready */
 359                 dev_warn(hostdata->dev, "Partner adapter not ready\n");
 360                 retrc = 0;
 361         } else if (rc != 0) {
 362                 dev_warn(hostdata->dev, "Error %d opening adapter\n", rc);
 363                 goto reg_crq_failed;
 364         }
 365
 366         queue->cur = 0;
 367         spin_lock_init(&queue->lock);
 368
 369         tasklet_init(&hostdata->srp_task, (void *)ibmvscsi_task,
 370                      (unsigned long)hostdata);
 371
 372         if (request_irq(vdev->irq,
 373                         ibmvscsi_handle_event,
 374                         0, "ibmvscsi", (void *)hostdata) != 0) {
 375                 dev_err(hostdata->dev, "couldn't register irq 0x%x\n",
 376                         vdev->irq);
 377                 goto req_irq_failed;
 378         }
 379
 380         rc = vio_enable_interrupts(vdev);
 381         if (rc != 0) {
 382                 dev_err(hostdata->dev, "Error %d enabling interrupts!!!\n", rc);
 383                 goto req_irq_failed;
 384         }
 385
 386         return retrc;
 387
 388       req_irq_failed:
 389         tasklet_kill(&hostdata->srp_task);
 390         rc = 0;
 391         do {
 392                 if (rc)
 393                         msleep(100);
 394                 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
 395         } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc)));
 396       reg_crq_failed:
 397         dma_unmap_single(hostdata->dev,
 398                          queue->msg_token,
 399                          queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
 400       map_failed:
 401         free_page((unsigned long)queue->msgs);
 402       malloc_failed:
 403         return -1;
 404 }
 405
 406 /**
 407  * reenable_crq_queue: - reenables a crq after
 408  * @queue:      crq_queue to initialize and register
 409  * @hostdata:   ibmvscsi_host_data of host
 410  *
 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, 0);
 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  * ibmvscsi_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 */
 534 static void free_event_struct(struct event_pool *pool,
 535                                        struct srp_event_struct *evt)
 536 {
 537         if (!valid_event_struct(pool, evt)) {
 538                 dev_err(evt->hostdata->dev, "Freeing invalid event_struct %p "
 539                         "(not in pool %p)\n", evt, pool->events);
 540                 return;
 541         }
 542         if (atomic_inc_return(&evt->free) != 1) {
 543                 dev_err(evt->hostdata->dev, "Freeing event_struct %p "
 544                         "which is not in use!\n", evt);
 545                 return;
 546         }
 547 }
 548
 549 /**
 550  * get_evt_struct: - Gets the next free event in pool
 551  * @pool:       event_pool that contains the events to be searched
 552  *
 553  * Returns the next event in "free" state, and NULL if none are free.
 554  * Note that no synchronization is done here, we assume the host_lock
 555  * will syncrhonze things.
 556 */
 557 static struct srp_event_struct *get_event_struct(struct event_pool *pool)
 558 {
 559         int i;
 560         int poolsize = pool->size;
 561         int offset = pool->next;
 562
 563         for (i = 0; i < poolsize; i++) {
 564                 offset = (offset + 1) % poolsize;
 565                 if (!atomic_dec_if_positive(&pool->events[offset].free)) {
 566                         pool->next = offset;
 567                         return &pool->events[offset];
 568                 }
 569         }
 570
 571         printk(KERN_ERR "ibmvscsi: found no event struct in pool!\n");
 572         return NULL;
 573 }
 574
 575 /**
 576  * init_event_struct: Initialize fields in an event struct that are always
 577  *                    required.
 578  * @evt:        The event
 579  * @done:       Routine to call when the event is responded to
 580  * @format:     SRP or MAD format
 581  * @timeout:    timeout value set in the CRQ
 582  */
 583 static void init_event_struct(struct srp_event_struct *evt_struct,
 584                               void (*done) (struct srp_event_struct *),
 585                               u8 format,
 586                               int timeout)
 587 {
 588         evt_struct->cmnd = NULL;
 589         evt_struct->cmnd_done = NULL;
 590         evt_struct->sync_srp = NULL;
 591         evt_struct->crq.format = format;
 592         evt_struct->crq.timeout = cpu_to_be16(timeout);
 593         evt_struct->done = done;
 594 }
 595
 596 /* ------------------------------------------------------------
 597  * Routines for receiving SCSI responses from the hosting partition
 598  */
 599
 600 /**
 601  * set_srp_direction: Set the fields in the srp related to data
 602  *     direction and number of buffers based on the direction in
 603  *     the scsi_cmnd and the number of buffers
 604  */
 605 static void set_srp_direction(struct scsi_cmnd *cmd,
 606                               struct srp_cmd *srp_cmd,
 607                               int numbuf)
 608 {
 609         u8 fmt;
 610
 611         if (numbuf == 0)
 612                 return;
 613
 614         if (numbuf == 1)
 615                 fmt = SRP_DATA_DESC_DIRECT;
 616         else {
 617                 fmt = SRP_DATA_DESC_INDIRECT;
 618                 numbuf = min(numbuf, MAX_INDIRECT_BUFS);
 619
 620                 if (cmd->sc_data_direction == DMA_TO_DEVICE)
 621                         srp_cmd->data_out_desc_cnt = numbuf;
 622                 else
 623                         srp_cmd->data_in_desc_cnt = numbuf;
 624         }
 625
 626         if (cmd->sc_data_direction == DMA_TO_DEVICE)
 627                 srp_cmd->buf_fmt = fmt << 4;
 628         else
 629                 srp_cmd->buf_fmt = fmt;
 630 }
 631
 632 /**
 633  * unmap_cmd_data: - Unmap data pointed in srp_cmd based on the format
 634  * @cmd:        srp_cmd whose additional_data member will be unmapped
 635  * @dev:        device for which the memory is mapped
 636  *
 637 */
 638 static void unmap_cmd_data(struct srp_cmd *cmd,
 639                            struct srp_event_struct *evt_struct,
 640                            struct device *dev)
 641 {
 642         u8 out_fmt, in_fmt;
 643
 644         out_fmt = cmd->buf_fmt >> 4;
 645         in_fmt = cmd->buf_fmt & ((1U << 4) - 1);
 646
 647         if (out_fmt == SRP_NO_DATA_DESC && in_fmt == SRP_NO_DATA_DESC)
 648                 return;
 649
 650         if (evt_struct->cmnd)
 651                 scsi_dma_unmap(evt_struct->cmnd);
 652 }
 653
 654 static int map_sg_list(struct scsi_cmnd *cmd, int nseg,
 655                        struct srp_direct_buf *md)
 656 {
 657         int i;
 658         struct scatterlist *sg;
 659         u64 total_length = 0;
 660
 661         scsi_for_each_sg(cmd, sg, nseg, i) {
 662                 struct srp_direct_buf *descr = md + i;
 663                 descr->va = cpu_to_be64(sg_dma_address(sg));
 664                 descr->len = cpu_to_be32(sg_dma_len(sg));
 665                 descr->key = 0;
 666                 total_length += sg_dma_len(sg);
 667         }
 668         return total_length;
 669 }
 670
 671 /**
 672  * map_sg_data: - Maps dma for a scatterlist and initializes descriptor fields
 673  * @cmd:        struct scsi_cmnd with the scatterlist
 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 = (struct srp_direct_buf *)
 721                         dma_alloc_coherent(dev,
 722                                            SG_ALL * sizeof(struct srp_direct_buf),
 723                                            &evt_struct->ext_list_token, 0);
 724                 if (!evt_struct->ext_list) {
 725                         if (!firmware_has_feature(FW_FEATURE_CMO))
 726                                 sdev_printk(KERN_ERR, cmd->device,
 727                                             "Can't allocate memory "
 728                                             "for indirect table\n");
 729                         scsi_dma_unmap(cmd);
 730                         return 0;
 731                 }
 732         }
 733
 734         total_length = map_sg_list(cmd, sg_mapped, evt_struct->ext_list);
 735
 736         indirect->len = cpu_to_be32(total_length);
 737         indirect->table_desc.va = cpu_to_be64(evt_struct->ext_list_token);
 738         indirect->table_desc.len = cpu_to_be32(sg_mapped *
 739                                                sizeof(indirect->desc_list[0]));
 740         memcpy(indirect->desc_list, evt_struct->ext_list,
 741                MAX_INDIRECT_BUFS * sizeof(struct srp_direct_buf));
 742         return 1;
 743 }
 744
 745 /**
 746  * map_data_for_srp_cmd: - Calls functions to map data for srp cmds
 747  * @cmd:        struct scsi_cmnd with the memory to be mapped
 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  */
 782 static void purge_requests(struct ibmvscsi_host_data *hostdata, int error_code)
 783 {
 784         struct srp_event_struct *evt;
 785         unsigned long flags;
 786
 787         spin_lock_irqsave(hostdata->host->host_lock, flags);
 788         while (!list_empty(&hostdata->sent)) {
 789                 evt = list_first_entry(&hostdata->sent, struct srp_event_struct, list);
 790                 list_del(&evt->list);
 791                 del_timer(&evt->timer);
 792
 793                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
 794                 if (evt->cmnd) {
 795                         evt->cmnd->result = (error_code << 16);
 796                         unmap_cmd_data(&evt->iu.srp.cmd, evt,
 797                                        evt->hostdata->dev);
 798                         if (evt->cmnd_done)
 799                                 evt->cmnd_done(evt->cmnd);
 800                 } else if (evt->done && evt->crq.format != VIOSRP_MAD_FORMAT &&
 801                            evt->iu.srp.login_req.opcode != SRP_LOGIN_REQ)
 802                         evt->done(evt);
 803                 free_event_struct(&evt->hostdata->pool, evt);
 804                 spin_lock_irqsave(hostdata->host->host_lock, flags);
 805         }
 806         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
 807 }
 808
 809 /**
 810  * ibmvscsi_set_request_limit - Set the adapter request_limit in response to
 811  * an adapter failure, reset, or SRP Login. Done under host lock to prevent
 812  * race with SCSI command submission.
 813  * @hostdata:   adapter to adjust
 814  * @limit:      new request limit
 815  */
 816 static void ibmvscsi_set_request_limit(struct ibmvscsi_host_data *hostdata, int limit)
 817 {
 818         unsigned long flags;
 819
 820         spin_lock_irqsave(hostdata->host->host_lock, flags);
 821         atomic_set(&hostdata->request_limit, limit);
 822         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
 823 }
 824
 825 /**
 826  * ibmvscsi_reset_host - Reset the connection to the server
 827  * @hostdata:   struct ibmvscsi_host_data to reset
 828 */
 829 static void ibmvscsi_reset_host(struct ibmvscsi_host_data *hostdata)
 830 {
 831         scsi_block_requests(hostdata->host);
 832         ibmvscsi_set_request_limit(hostdata, 0);
 833
 834         purge_requests(hostdata, DID_ERROR);
 835         hostdata->action = IBMVSCSI_HOST_ACTION_RESET;
 836         wake_up(&hostdata->work_wait_q);
 837 }
 838
 839 /**
 840  * ibmvscsi_timeout - Internal command timeout handler
 841  * @evt_struct: struct srp_event_struct that timed out
 842  *
 843  * Called when an internally generated command times out
 844 */
 845 static void ibmvscsi_timeout(struct timer_list *t)
 846 {
 847         struct srp_event_struct *evt_struct = from_timer(evt_struct, t, timer);
 848         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
 849
 850         dev_err(hostdata->dev, "Command timed out (%x). Resetting connection\n",
 851                 evt_struct->iu.srp.cmd.opcode);
 852
 853         ibmvscsi_reset_host(hostdata);
 854 }
 855
 856
 857 /* ------------------------------------------------------------
 858  * Routines for sending and receiving SRPs
 859  */
 860 /**
 861  * ibmvscsi_send_srp_event: - Transforms event to u64 array and calls send_crq()
 862  * @evt_struct: evt_struct to be sent
 863  * @hostdata:   ibmvscsi_host_data of host
 864  * @timeout:    timeout in seconds - 0 means do not time command
 865  *
 866  * Returns the value returned from ibmvscsi_send_crq(). (Zero for success)
 867  * Note that this routine assumes that host_lock is held for synchronization
 868 */
 869 static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
 870                                    struct ibmvscsi_host_data *hostdata,
 871                                    unsigned long timeout)
 872 {
 873         __be64 *crq_as_u64 = (__be64 *)&evt_struct->crq;
 874         int request_status = 0;
 875         int rc;
 876         int srp_req = 0;
 877
 878         /* If we have exhausted our request limit, just fail this request,
 879          * unless it is for a reset or abort.
 880          * Note that there are rare cases involving driver generated requests
 881          * (such as task management requests) that the mid layer may think we
 882          * can handle more requests (can_queue) when we actually can't
 883          */
 884         if (evt_struct->crq.format == VIOSRP_SRP_FORMAT) {
 885                 srp_req = 1;
 886                 request_status =
 887                         atomic_dec_if_positive(&hostdata->request_limit);
 888                 /* If request limit was -1 when we started, it is now even
 889                  * less than that
 890                  */
 891                 if (request_status < -1)
 892                         goto send_error;
 893                 /* Otherwise, we may have run out of requests. */
 894                 /* If request limit was 0 when we started the adapter is in the
 895                  * process of performing a login with the server adapter, or
 896                  * we may have run out of requests.
 897                  */
 898                 else if (request_status == -1 &&
 899                          evt_struct->iu.srp.login_req.opcode != SRP_LOGIN_REQ)
 900                         goto send_busy;
 901                 /* Abort and reset calls should make it through.
 902                  * Nothing except abort and reset should use the last two
 903                  * slots unless we had two or less to begin with.
 904                  */
 905                 else if (request_status < 2 &&
 906                          evt_struct->iu.srp.cmd.opcode != SRP_TSK_MGMT) {
 907                         /* In the case that we have less than two requests
 908                          * available, check the server limit as a combination
 909                          * of the request limit and the number of requests
 910                          * in-flight (the size of the send list).  If the
 911                          * server limit is greater than 2, return busy so
 912                          * that the last two are reserved for reset and abort.
 913                          */
 914                         int server_limit = request_status;
 915                         struct srp_event_struct *tmp_evt;
 916
 917                         list_for_each_entry(tmp_evt, &hostdata->sent, list) {
 918                                 server_limit++;
 919                         }
 920
 921                         if (server_limit > 2)
 922                                 goto send_busy;
 923                 }
 924         }
 925
 926         /* Copy the IU into the transfer area */
 927         *evt_struct->xfer_iu = evt_struct->iu;
 928         evt_struct->xfer_iu->srp.rsp.tag = (u64)evt_struct;
 929
 930         /* Add this to the sent list.  We need to do this
 931          * before we actually send
 932          * in case it comes back REALLY fast
 933          */
 934         list_add_tail(&evt_struct->list, &hostdata->sent);
 935
 936         timer_setup(&evt_struct->timer, ibmvscsi_timeout, 0);
 937         if (timeout) {
 938                 evt_struct->timer.expires = jiffies + (timeout * HZ);
 939                 add_timer(&evt_struct->timer);
 940         }
 941
 942         rc = ibmvscsi_send_crq(hostdata, be64_to_cpu(crq_as_u64[0]),
 943                                be64_to_cpu(crq_as_u64[1]));
 944         if (rc != 0) {
 945                 list_del(&evt_struct->list);
 946                 del_timer(&evt_struct->timer);
 947
 948                 /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY.
 949                  * Firmware will send a CRQ with a transport event (0xFF) to
 950                  * tell this client what has happened to the transport.  This
 951                  * will be handled in ibmvscsi_handle_crq()
 952                  */
 953                 if (rc == H_CLOSED) {
 954                         dev_warn(hostdata->dev, "send warning. "
 955                                  "Receive queue closed, will retry.\n");
 956                         goto send_busy;
 957                 }
 958                 dev_err(hostdata->dev, "send error %d\n", rc);
 959                 if (srp_req)
 960                         atomic_inc(&hostdata->request_limit);
 961                 goto send_error;
 962         }
 963
 964         return 0;
 965
 966  send_busy:
 967         unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev);
 968
 969         free_event_struct(&hostdata->pool, evt_struct);
 970         if (srp_req && request_status != -1)
 971                 atomic_inc(&hostdata->request_limit);
 972         return SCSI_MLQUEUE_HOST_BUSY;
 973
 974  send_error:
 975         unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev);
 976
 977         if (evt_struct->cmnd != NULL) {
 978                 evt_struct->cmnd->result = DID_ERROR << 16;
 979                 evt_struct->cmnd_done(evt_struct->cmnd);
 980         } else if (evt_struct->done)
 981                 evt_struct->done(evt_struct);
 982
 983         free_event_struct(&hostdata->pool, evt_struct);
 984         return 0;
 985 }
 986
 987 /**
 988  * handle_cmd_rsp: -  Handle responses from commands
 989  * @evt_struct: srp_event_struct to be handled
 990  *
 991  * Used as a callback by when sending scsi cmds.
 992  * Gets called by ibmvscsi_handle_crq()
 993 */
 994 static void handle_cmd_rsp(struct srp_event_struct *evt_struct)
 995 {
 996         struct srp_rsp *rsp = &evt_struct->xfer_iu->srp.rsp;
 997         struct scsi_cmnd *cmnd = evt_struct->cmnd;
 998
 999         if (unlikely(rsp->opcode != SRP_RSP)) {
1000                 if (printk_ratelimit())
1001                         dev_warn(evt_struct->hostdata->dev,
1002                                  "bad SRP RSP type %#02x\n", rsp->opcode);
1003         }
1004
1005         if (cmnd) {
1006                 cmnd->result |= rsp->status;
1007                 if (((cmnd->result >> 1) & 0x1f) == CHECK_CONDITION)
1008                         memcpy(cmnd->sense_buffer,
1009                                rsp->data,
1010                                be32_to_cpu(rsp->sense_data_len));
1011                 unmap_cmd_data(&evt_struct->iu.srp.cmd,
1012                                evt_struct,
1013                                evt_struct->hostdata->dev);
1014
1015                 if (rsp->flags & SRP_RSP_FLAG_DOOVER)
1016                         scsi_set_resid(cmnd,
1017                                        be32_to_cpu(rsp->data_out_res_cnt));
1018                 else if (rsp->flags & SRP_RSP_FLAG_DIOVER)
1019                         scsi_set_resid(cmnd, be32_to_cpu(rsp->data_in_res_cnt));
1020         }
1021
1022         if (evt_struct->cmnd_done)
1023                 evt_struct->cmnd_done(cmnd);
1024 }
1025
1026 /**
1027  * lun_from_dev: - Returns the lun of the scsi device
1028  * @dev:        struct scsi_device
1029  *
1030 */
1031 static inline u16 lun_from_dev(struct scsi_device *dev)
1032 {
1033         return (0x2 << 14) | (dev->id << 8) | (dev->channel << 5) | dev->lun;
1034 }
1035
1036 /**
1037  * ibmvscsi_queue: - The queuecommand function of the scsi template
1038  * @cmd:        struct scsi_cmnd to be executed
1039  * @done:       Callback function to be called when cmd is completed
1040 */
1041 static int ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd,
1042                                  void (*done) (struct scsi_cmnd *))
1043 {
1044         struct srp_cmd *srp_cmd;
1045         struct srp_event_struct *evt_struct;
1046         struct srp_indirect_buf *indirect;
1047         struct ibmvscsi_host_data *hostdata = shost_priv(cmnd->device->host);
1048         u16 lun = lun_from_dev(cmnd->device);
1049         u8 out_fmt, in_fmt;
1050
1051         cmnd->result = (DID_OK << 16);
1052         evt_struct = get_event_struct(&hostdata->pool);
1053         if (!evt_struct)
1054                 return SCSI_MLQUEUE_HOST_BUSY;
1055
1056         /* Set up the actual SRP IU */
1057         srp_cmd = &evt_struct->iu.srp.cmd;
1058         memset(srp_cmd, 0x00, SRP_MAX_IU_LEN);
1059         srp_cmd->opcode = SRP_CMD;
1060         memcpy(srp_cmd->cdb, cmnd->cmnd, sizeof(srp_cmd->cdb));
1061         int_to_scsilun(lun, &srp_cmd->lun);
1062
1063         if (!map_data_for_srp_cmd(cmnd, evt_struct, srp_cmd, hostdata->dev)) {
1064                 if (!firmware_has_feature(FW_FEATURE_CMO))
1065                         sdev_printk(KERN_ERR, cmnd->device,
1066                                     "couldn't convert cmd to srp_cmd\n");
1067                 free_event_struct(&hostdata->pool, evt_struct);
1068                 return SCSI_MLQUEUE_HOST_BUSY;
1069         }
1070
1071         init_event_struct(evt_struct,
1072                           handle_cmd_rsp,
1073                           VIOSRP_SRP_FORMAT,
1074                           cmnd->request->timeout/HZ);
1075
1076         evt_struct->cmnd = cmnd;
1077         evt_struct->cmnd_done = done;
1078
1079         /* Fix up dma address of the buffer itself */
1080         indirect = (struct srp_indirect_buf *) srp_cmd->add_data;
1081         out_fmt = srp_cmd->buf_fmt >> 4;
1082         in_fmt = srp_cmd->buf_fmt & ((1U << 4) - 1);
1083         if ((in_fmt == SRP_DATA_DESC_INDIRECT ||
1084              out_fmt == SRP_DATA_DESC_INDIRECT) &&
1085             indirect->table_desc.va == 0) {
1086                 indirect->table_desc.va =
1087                         cpu_to_be64(be64_to_cpu(evt_struct->crq.IU_data_ptr) +
1088                         offsetof(struct srp_cmd, add_data) +
1089                         offsetof(struct srp_indirect_buf, desc_list));
1090         }
1091
1092         return ibmvscsi_send_srp_event(evt_struct, hostdata, 0);
1093 }
1094
1095 static DEF_SCSI_QCMD(ibmvscsi_queuecommand)
1096
1097 /* ------------------------------------------------------------
1098  * Routines for driver initialization
1099  */
1100
1101 /**
1102  * map_persist_bufs: - Pre-map persistent data for adapter logins
1103  * @hostdata:   ibmvscsi_host_data of host
1104  *
1105  * Map the capabilities and adapter info DMA buffers to avoid runtime failures.
1106  * Return 1 on error, 0 on success.
1107  */
1108 static int map_persist_bufs(struct ibmvscsi_host_data *hostdata)
1109 {
1110
1111         hostdata->caps_addr = dma_map_single(hostdata->dev, &hostdata->caps,
1112                                              sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1113
1114         if (dma_mapping_error(hostdata->dev, hostdata->caps_addr)) {
1115                 dev_err(hostdata->dev, "Unable to map capabilities buffer!\n");
1116                 return 1;
1117         }
1118
1119         hostdata->adapter_info_addr = dma_map_single(hostdata->dev,
1120                                                      &hostdata->madapter_info,
1121                                                      sizeof(hostdata->madapter_info),
1122                                                      DMA_BIDIRECTIONAL);
1123         if (dma_mapping_error(hostdata->dev, hostdata->adapter_info_addr)) {
1124                 dev_err(hostdata->dev, "Unable to map adapter info buffer!\n");
1125                 dma_unmap_single(hostdata->dev, hostdata->caps_addr,
1126                                  sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1127                 return 1;
1128         }
1129
1130         return 0;
1131 }
1132
1133 /**
1134  * unmap_persist_bufs: - Unmap persistent data needed for adapter logins
1135  * @hostdata:   ibmvscsi_host_data of host
1136  *
1137  * Unmap the capabilities and adapter info DMA buffers
1138  */
1139 static void unmap_persist_bufs(struct ibmvscsi_host_data *hostdata)
1140 {
1141         dma_unmap_single(hostdata->dev, hostdata->caps_addr,
1142                          sizeof(hostdata->caps), DMA_BIDIRECTIONAL);
1143
1144         dma_unmap_single(hostdata->dev, hostdata->adapter_info_addr,
1145                          sizeof(hostdata->madapter_info), DMA_BIDIRECTIONAL);
1146 }
1147
1148 /**
1149  * login_rsp: - Handle response to SRP login request
1150  * @evt_struct: srp_event_struct with the response
1151  *
1152  * Used as a "done" callback by when sending srp_login. Gets called
1153  * by ibmvscsi_handle_crq()
1154 */
1155 static void login_rsp(struct srp_event_struct *evt_struct)
1156 {
1157         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1158         switch (evt_struct->xfer_iu->srp.login_rsp.opcode) {
1159         case SRP_LOGIN_RSP:     /* it worked! */
1160                 break;
1161         case SRP_LOGIN_REJ:     /* refused! */
1162                 dev_info(hostdata->dev, "SRP_LOGIN_REJ reason %u\n",
1163                          evt_struct->xfer_iu->srp.login_rej.reason);
1164                 /* Login failed.  */
1165                 ibmvscsi_set_request_limit(hostdata, -1);
1166                 return;
1167         default:
1168                 dev_err(hostdata->dev, "Invalid login response typecode 0x%02x!\n",
1169                         evt_struct->xfer_iu->srp.login_rsp.opcode);
1170                 /* Login failed.  */
1171                 ibmvscsi_set_request_limit(hostdata, -1);
1172                 return;
1173         }
1174
1175         dev_info(hostdata->dev, "SRP_LOGIN succeeded\n");
1176         hostdata->client_migrated = 0;
1177
1178         /* Now we know what the real request-limit is.
1179          * This value is set rather than added to request_limit because
1180          * request_limit could have been set to -1 by this client.
1181          */
1182         ibmvscsi_set_request_limit(hostdata,
1183                    be32_to_cpu(evt_struct->xfer_iu->srp.login_rsp.req_lim_delta));
1184
1185         /* If we had any pending I/Os, kick them */
1186         hostdata->action = IBMVSCSI_HOST_ACTION_UNBLOCK;
1187         wake_up(&hostdata->work_wait_q);
1188 }
1189
1190 /**
1191  * send_srp_login: - Sends the srp login
1192  * @hostdata:   ibmvscsi_host_data of host
1193  *
1194  * Returns zero if successful.
1195 */
1196 static int send_srp_login(struct ibmvscsi_host_data *hostdata)
1197 {
1198         int rc;
1199         unsigned long flags;
1200         struct srp_login_req *login;
1201         struct srp_event_struct *evt_struct = get_event_struct(&hostdata->pool);
1202
1203         BUG_ON(!evt_struct);
1204         init_event_struct(evt_struct, login_rsp,
1205                           VIOSRP_SRP_FORMAT, login_timeout);
1206
1207         login = &evt_struct->iu.srp.login_req;
1208         memset(login, 0, sizeof(*login));
1209         login->opcode = SRP_LOGIN_REQ;
1210         login->req_it_iu_len = cpu_to_be32(sizeof(union srp_iu));
1211         login->req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
1212                                          SRP_BUF_FORMAT_INDIRECT);
1213
1214         /* Start out with a request limit of 0, since this is negotiated in
1215          * the login request we are just sending and login requests always
1216          * get sent by the driver regardless of request_limit.
1217          */
1218         ibmvscsi_set_request_limit(hostdata, 0);
1219
1220         spin_lock_irqsave(hostdata->host->host_lock, flags);
1221         rc = ibmvscsi_send_srp_event(evt_struct, hostdata, login_timeout * 2);
1222         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1223         dev_info(hostdata->dev, "sent SRP login\n");
1224         return rc;
1225 };
1226
1227 /**
1228  * capabilities_rsp: - Handle response to MAD adapter capabilities request
1229  * @evt_struct: srp_event_struct with the response
1230  *
1231  * Used as a "done" callback by when sending adapter_info.
1232  */
1233 static void capabilities_rsp(struct srp_event_struct *evt_struct)
1234 {
1235         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1236
1237         if (evt_struct->xfer_iu->mad.capabilities.common.status) {
1238                 dev_err(hostdata->dev, "error 0x%X getting capabilities info\n",
1239                         evt_struct->xfer_iu->mad.capabilities.common.status);
1240         } else {
1241                 if (hostdata->caps.migration.common.server_support !=
1242                     cpu_to_be16(SERVER_SUPPORTS_CAP))
1243                         dev_info(hostdata->dev, "Partition migration not supported\n");
1244
1245                 if (client_reserve) {
1246                         if (hostdata->caps.reserve.common.server_support ==
1247                             cpu_to_be16(SERVER_SUPPORTS_CAP))
1248                                 dev_info(hostdata->dev, "Client reserve enabled\n");
1249                         else
1250                                 dev_info(hostdata->dev, "Client reserve not supported\n");
1251                 }
1252         }
1253
1254         send_srp_login(hostdata);
1255 }
1256
1257 /**
1258  * send_mad_capabilities: - Sends the mad capabilities request
1259  *      and stores the result so it can be retrieved with
1260  * @hostdata:   ibmvscsi_host_data of host
1261  */
1262 static void send_mad_capabilities(struct ibmvscsi_host_data *hostdata)
1263 {
1264         struct viosrp_capabilities *req;
1265         struct srp_event_struct *evt_struct;
1266         unsigned long flags;
1267         struct device_node *of_node = hostdata->dev->of_node;
1268         const char *location;
1269
1270         evt_struct = get_event_struct(&hostdata->pool);
1271         BUG_ON(!evt_struct);
1272
1273         init_event_struct(evt_struct, capabilities_rsp,
1274                           VIOSRP_MAD_FORMAT, info_timeout);
1275
1276         req = &evt_struct->iu.mad.capabilities;
1277         memset(req, 0, sizeof(*req));
1278
1279         hostdata->caps.flags = cpu_to_be32(CAP_LIST_SUPPORTED);
1280         if (hostdata->client_migrated)
1281                 hostdata->caps.flags |= cpu_to_be32(CLIENT_MIGRATED);
1282
1283         strlcpy(hostdata->caps.name, dev_name(&hostdata->host->shost_gendev),
1284                 sizeof(hostdata->caps.name));
1285
1286         location = of_get_property(of_node, "ibm,loc-code", NULL);
1287         location = location ? location : dev_name(hostdata->dev);
1288         strlcpy(hostdata->caps.loc, location, sizeof(hostdata->caps.loc));
1289
1290         req->common.type = cpu_to_be32(VIOSRP_CAPABILITIES_TYPE);
1291         req->buffer = cpu_to_be64(hostdata->caps_addr);
1292
1293         hostdata->caps.migration.common.cap_type =
1294                                 cpu_to_be32(MIGRATION_CAPABILITIES);
1295         hostdata->caps.migration.common.length =
1296                                 cpu_to_be16(sizeof(hostdata->caps.migration));
1297         hostdata->caps.migration.common.server_support =
1298                                 cpu_to_be16(SERVER_SUPPORTS_CAP);
1299         hostdata->caps.migration.ecl = cpu_to_be32(1);
1300
1301         if (client_reserve) {
1302                 hostdata->caps.reserve.common.cap_type =
1303                                         cpu_to_be32(RESERVATION_CAPABILITIES);
1304                 hostdata->caps.reserve.common.length =
1305                                 cpu_to_be16(sizeof(hostdata->caps.reserve));
1306                 hostdata->caps.reserve.common.server_support =
1307                                 cpu_to_be16(SERVER_SUPPORTS_CAP);
1308                 hostdata->caps.reserve.type =
1309                                 cpu_to_be32(CLIENT_RESERVE_SCSI_2);
1310                 req->common.length =
1311                                 cpu_to_be16(sizeof(hostdata->caps));
1312         } else
1313                 req->common.length = cpu_to_be16(sizeof(hostdata->caps) -
1314                                                 sizeof(hostdata->caps.reserve));
1315
1316         spin_lock_irqsave(hostdata->host->host_lock, flags);
1317         if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2))
1318                 dev_err(hostdata->dev, "couldn't send CAPABILITIES_REQ!\n");
1319         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1320 };
1321
1322 /**
1323  * fast_fail_rsp: - Handle response to MAD enable fast fail
1324  * @evt_struct: srp_event_struct with the response
1325  *
1326  * Used as a "done" callback by when sending enable fast fail. Gets called
1327  * by ibmvscsi_handle_crq()
1328  */
1329 static void fast_fail_rsp(struct srp_event_struct *evt_struct)
1330 {
1331         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1332         u16 status = be16_to_cpu(evt_struct->xfer_iu->mad.fast_fail.common.status);
1333
1334         if (status == VIOSRP_MAD_NOT_SUPPORTED)
1335                 dev_err(hostdata->dev, "fast_fail not supported in server\n");
1336         else if (status == VIOSRP_MAD_FAILED)
1337                 dev_err(hostdata->dev, "fast_fail request failed\n");
1338         else if (status != VIOSRP_MAD_SUCCESS)
1339                 dev_err(hostdata->dev, "error 0x%X enabling fast_fail\n", status);
1340
1341         send_mad_capabilities(hostdata);
1342 }
1343
1344 /**
1345  * init_host - Start host initialization
1346  * @hostdata:   ibmvscsi_host_data of host
1347  *
1348  * Returns zero if successful.
1349  */
1350 static int enable_fast_fail(struct ibmvscsi_host_data *hostdata)
1351 {
1352         int rc;
1353         unsigned long flags;
1354         struct viosrp_fast_fail *fast_fail_mad;
1355         struct srp_event_struct *evt_struct;
1356
1357         if (!fast_fail) {
1358                 send_mad_capabilities(hostdata);
1359                 return 0;
1360         }
1361
1362         evt_struct = get_event_struct(&hostdata->pool);
1363         BUG_ON(!evt_struct);
1364
1365         init_event_struct(evt_struct, fast_fail_rsp, VIOSRP_MAD_FORMAT, info_timeout);
1366
1367         fast_fail_mad = &evt_struct->iu.mad.fast_fail;
1368         memset(fast_fail_mad, 0, sizeof(*fast_fail_mad));
1369         fast_fail_mad->common.type = cpu_to_be32(VIOSRP_ENABLE_FAST_FAIL);
1370         fast_fail_mad->common.length = cpu_to_be16(sizeof(*fast_fail_mad));
1371
1372         spin_lock_irqsave(hostdata->host->host_lock, flags);
1373         rc = ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2);
1374         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1375         return rc;
1376 }
1377
1378 /**
1379  * adapter_info_rsp: - Handle response to MAD adapter info request
1380  * @evt_struct: srp_event_struct with the response
1381  *
1382  * Used as a "done" callback by when sending adapter_info. Gets called
1383  * by ibmvscsi_handle_crq()
1384 */
1385 static void adapter_info_rsp(struct srp_event_struct *evt_struct)
1386 {
1387         struct ibmvscsi_host_data *hostdata = evt_struct->hostdata;
1388
1389         if (evt_struct->xfer_iu->mad.adapter_info.common.status) {
1390                 dev_err(hostdata->dev, "error %d getting adapter info\n",
1391                         evt_struct->xfer_iu->mad.adapter_info.common.status);
1392         } else {
1393                 dev_info(hostdata->dev, "host srp version: %s, "
1394                          "host partition %s (%d), OS %d, max io %u\n",
1395                          hostdata->madapter_info.srp_version,
1396                          hostdata->madapter_info.partition_name,
1397                          be32_to_cpu(hostdata->madapter_info.partition_number),
1398                          be32_to_cpu(hostdata->madapter_info.os_type),
1399                          be32_to_cpu(hostdata->madapter_info.port_max_txu[0]));
1400
1401                 if (hostdata->madapter_info.port_max_txu[0])
1402                         hostdata->host->max_sectors =
1403                                 be32_to_cpu(hostdata->madapter_info.port_max_txu[0]) >> 9;
1404
1405                 if (be32_to_cpu(hostdata->madapter_info.os_type) == SRP_MAD_OS_AIX &&
1406                     strcmp(hostdata->madapter_info.srp_version, "1.6a") <= 0) {
1407                         dev_err(hostdata->dev, "host (Ver. %s) doesn't support large transfers\n",
1408                                 hostdata->madapter_info.srp_version);
1409                         dev_err(hostdata->dev, "limiting scatterlists to %d\n",
1410                                 MAX_INDIRECT_BUFS);
1411                         hostdata->host->sg_tablesize = MAX_INDIRECT_BUFS;
1412                 }
1413
1414                 if (be32_to_cpu(hostdata->madapter_info.os_type) == SRP_MAD_OS_AIX) {
1415                         enable_fast_fail(hostdata);
1416                         return;
1417                 }
1418         }
1419
1420         send_srp_login(hostdata);
1421 }
1422
1423 /**
1424  * send_mad_adapter_info: - Sends the mad adapter info request
1425  *      and stores the result so it can be retrieved with
1426  *      sysfs.  We COULD consider causing a failure if the
1427  *      returned SRP version doesn't match ours.
1428  * @hostdata:   ibmvscsi_host_data of host
1429  *
1430  * Returns zero if successful.
1431 */
1432 static void send_mad_adapter_info(struct ibmvscsi_host_data *hostdata)
1433 {
1434         struct viosrp_adapter_info *req;
1435         struct srp_event_struct *evt_struct;
1436         unsigned long flags;
1437
1438         evt_struct = get_event_struct(&hostdata->pool);
1439         BUG_ON(!evt_struct);
1440
1441         init_event_struct(evt_struct,
1442                           adapter_info_rsp,
1443                           VIOSRP_MAD_FORMAT,
1444                           info_timeout);
1445
1446         req = &evt_struct->iu.mad.adapter_info;
1447         memset(req, 0x00, sizeof(*req));
1448
1449         req->common.type = cpu_to_be32(VIOSRP_ADAPTER_INFO_TYPE);
1450         req->common.length = cpu_to_be16(sizeof(hostdata->madapter_info));
1451         req->buffer = cpu_to_be64(hostdata->adapter_info_addr);
1452
1453         spin_lock_irqsave(hostdata->host->host_lock, flags);
1454         if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2))
1455                 dev_err(hostdata->dev, "couldn't send ADAPTER_INFO_REQ!\n");
1456         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1457 };
1458
1459 /**
1460  * init_adapter: Start virtual adapter initialization sequence
1461  *
1462  */
1463 static void init_adapter(struct ibmvscsi_host_data *hostdata)
1464 {
1465         send_mad_adapter_info(hostdata);
1466 }
1467
1468 /**
1469  * sync_completion: Signal that a synchronous command has completed
1470  * Note that after returning from this call, the evt_struct is freed.
1471  * the caller waiting on this completion shouldn't touch the evt_struct
1472  * again.
1473  */
1474 static void sync_completion(struct srp_event_struct *evt_struct)
1475 {
1476         /* copy the response back */
1477         if (evt_struct->sync_srp)
1478                 *evt_struct->sync_srp = *evt_struct->xfer_iu;
1479
1480         complete(&evt_struct->comp);
1481 }
1482
1483 /**
1484  * ibmvscsi_abort: Abort a command...from scsi host template
1485  * send this over to the server and wait synchronously for the response
1486  */
1487 static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
1488 {
1489         struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1490         struct srp_tsk_mgmt *tsk_mgmt;
1491         struct srp_event_struct *evt;
1492         struct srp_event_struct *tmp_evt, *found_evt;
1493         union viosrp_iu srp_rsp;
1494         int rsp_rc;
1495         unsigned long flags;
1496         u16 lun = lun_from_dev(cmd->device);
1497         unsigned long wait_switch = 0;
1498
1499         /* First, find this command in our sent list so we can figure
1500          * out the correct tag
1501          */
1502         spin_lock_irqsave(hostdata->host->host_lock, flags);
1503         wait_switch = jiffies + (init_timeout * HZ);
1504         do {
1505                 found_evt = NULL;
1506                 list_for_each_entry(tmp_evt, &hostdata->sent, list) {
1507                         if (tmp_evt->cmnd == cmd) {
1508                                 found_evt = tmp_evt;
1509                                 break;
1510                         }
1511                 }
1512
1513                 if (!found_evt) {
1514                         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1515                         return SUCCESS;
1516                 }
1517
1518                 evt = get_event_struct(&hostdata->pool);
1519                 if (evt == NULL) {
1520                         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1521                         sdev_printk(KERN_ERR, cmd->device,
1522                                 "failed to allocate abort event\n");
1523                         return FAILED;
1524                 }
1525
1526                 init_event_struct(evt,
1527                                   sync_completion,
1528                                   VIOSRP_SRP_FORMAT,
1529                                   abort_timeout);
1530
1531                 tsk_mgmt = &evt->iu.srp.tsk_mgmt;
1532
1533                 /* Set up an abort SRP command */
1534                 memset(tsk_mgmt, 0x00, sizeof(*tsk_mgmt));
1535                 tsk_mgmt->opcode = SRP_TSK_MGMT;
1536                 int_to_scsilun(lun, &tsk_mgmt->lun);
1537                 tsk_mgmt->tsk_mgmt_func = SRP_TSK_ABORT_TASK;
1538                 tsk_mgmt->task_tag = (u64) found_evt;
1539
1540                 evt->sync_srp = &srp_rsp;
1541
1542                 init_completion(&evt->comp);
1543                 rsp_rc = ibmvscsi_send_srp_event(evt, hostdata, abort_timeout * 2);
1544
1545                 if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY)
1546                         break;
1547
1548                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1549                 msleep(10);
1550                 spin_lock_irqsave(hostdata->host->host_lock, flags);
1551         } while (time_before(jiffies, wait_switch));
1552
1553         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1554
1555         if (rsp_rc != 0) {
1556                 sdev_printk(KERN_ERR, cmd->device,
1557                             "failed to send abort() event. rc=%d\n", rsp_rc);
1558                 return FAILED;
1559         }
1560
1561         sdev_printk(KERN_INFO, cmd->device,
1562                     "aborting command. lun 0x%llx, tag 0x%llx\n",
1563                     (((u64) lun) << 48), (u64) found_evt);
1564
1565         wait_for_completion(&evt->comp);
1566
1567         /* make sure we got a good response */
1568         if (unlikely(srp_rsp.srp.rsp.opcode != SRP_RSP)) {
1569                 if (printk_ratelimit())
1570                         sdev_printk(KERN_WARNING, cmd->device, "abort bad SRP RSP type %d\n",
1571                                     srp_rsp.srp.rsp.opcode);
1572                 return FAILED;
1573         }
1574
1575         if (srp_rsp.srp.rsp.flags & SRP_RSP_FLAG_RSPVALID)
1576                 rsp_rc = *((int *)srp_rsp.srp.rsp.data);
1577         else
1578                 rsp_rc = srp_rsp.srp.rsp.status;
1579
1580         if (rsp_rc) {
1581                 if (printk_ratelimit())
1582                         sdev_printk(KERN_WARNING, cmd->device,
1583                                     "abort code %d for task tag 0x%llx\n",
1584                                     rsp_rc, tsk_mgmt->task_tag);
1585                 return FAILED;
1586         }
1587
1588         /* Because we dropped the spinlock above, it's possible
1589          * The event is no longer in our list.  Make sure it didn't
1590          * complete while we were aborting
1591          */
1592         spin_lock_irqsave(hostdata->host->host_lock, flags);
1593         found_evt = NULL;
1594         list_for_each_entry(tmp_evt, &hostdata->sent, list) {
1595                 if (tmp_evt->cmnd == cmd) {
1596                         found_evt = tmp_evt;
1597                         break;
1598                 }
1599         }
1600
1601         if (found_evt == NULL) {
1602                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1603                 sdev_printk(KERN_INFO, cmd->device, "aborted task tag 0x%llx completed\n",
1604                             tsk_mgmt->task_tag);
1605                 return SUCCESS;
1606         }
1607
1608         sdev_printk(KERN_INFO, cmd->device, "successfully aborted task tag 0x%llx\n",
1609                     tsk_mgmt->task_tag);
1610
1611         cmd->result = (DID_ABORT << 16);
1612         list_del(&found_evt->list);
1613         unmap_cmd_data(&found_evt->iu.srp.cmd, found_evt,
1614                        found_evt->hostdata->dev);
1615         free_event_struct(&found_evt->hostdata->pool, found_evt);
1616         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1617         atomic_inc(&hostdata->request_limit);
1618         return SUCCESS;
1619 }
1620
1621 /**
1622  * ibmvscsi_eh_device_reset_handler: Reset a single LUN...from scsi host
1623  * template send this over to the server and wait synchronously for the
1624  * response
1625  */
1626 static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
1627 {
1628         struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1629         struct srp_tsk_mgmt *tsk_mgmt;
1630         struct srp_event_struct *evt;
1631         struct srp_event_struct *tmp_evt, *pos;
1632         union viosrp_iu srp_rsp;
1633         int rsp_rc;
1634         unsigned long flags;
1635         u16 lun = lun_from_dev(cmd->device);
1636         unsigned long wait_switch = 0;
1637
1638         spin_lock_irqsave(hostdata->host->host_lock, flags);
1639         wait_switch = jiffies + (init_timeout * HZ);
1640         do {
1641                 evt = get_event_struct(&hostdata->pool);
1642                 if (evt == NULL) {
1643                         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1644                         sdev_printk(KERN_ERR, cmd->device,
1645                                 "failed to allocate reset event\n");
1646                         return FAILED;
1647                 }
1648
1649                 init_event_struct(evt,
1650                                   sync_completion,
1651                                   VIOSRP_SRP_FORMAT,
1652                                   reset_timeout);
1653
1654                 tsk_mgmt = &evt->iu.srp.tsk_mgmt;
1655
1656                 /* Set up a lun reset SRP command */
1657                 memset(tsk_mgmt, 0x00, sizeof(*tsk_mgmt));
1658                 tsk_mgmt->opcode = SRP_TSK_MGMT;
1659                 int_to_scsilun(lun, &tsk_mgmt->lun);
1660                 tsk_mgmt->tsk_mgmt_func = SRP_TSK_LUN_RESET;
1661
1662                 evt->sync_srp = &srp_rsp;
1663
1664                 init_completion(&evt->comp);
1665                 rsp_rc = ibmvscsi_send_srp_event(evt, hostdata, reset_timeout * 2);
1666
1667                 if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY)
1668                         break;
1669
1670                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1671                 msleep(10);
1672                 spin_lock_irqsave(hostdata->host->host_lock, flags);
1673         } while (time_before(jiffies, wait_switch));
1674
1675         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1676
1677         if (rsp_rc != 0) {
1678                 sdev_printk(KERN_ERR, cmd->device,
1679                             "failed to send reset event. rc=%d\n", rsp_rc);
1680                 return FAILED;
1681         }
1682
1683         sdev_printk(KERN_INFO, cmd->device, "resetting device. lun 0x%llx\n",
1684                     (((u64) lun) << 48));
1685
1686         wait_for_completion(&evt->comp);
1687
1688         /* make sure we got a good response */
1689         if (unlikely(srp_rsp.srp.rsp.opcode != SRP_RSP)) {
1690                 if (printk_ratelimit())
1691                         sdev_printk(KERN_WARNING, cmd->device, "reset bad SRP RSP type %d\n",
1692                                     srp_rsp.srp.rsp.opcode);
1693                 return FAILED;
1694         }
1695
1696         if (srp_rsp.srp.rsp.flags & SRP_RSP_FLAG_RSPVALID)
1697                 rsp_rc = *((int *)srp_rsp.srp.rsp.data);
1698         else
1699                 rsp_rc = srp_rsp.srp.rsp.status;
1700
1701         if (rsp_rc) {
1702                 if (printk_ratelimit())
1703                         sdev_printk(KERN_WARNING, cmd->device,
1704                                     "reset code %d for task tag 0x%llx\n",
1705                                     rsp_rc, tsk_mgmt->task_tag);
1706                 return FAILED;
1707         }
1708
1709         /* We need to find all commands for this LUN that have not yet been
1710          * responded to, and fail them with DID_RESET
1711          */
1712         spin_lock_irqsave(hostdata->host->host_lock, flags);
1713         list_for_each_entry_safe(tmp_evt, pos, &hostdata->sent, list) {
1714                 if ((tmp_evt->cmnd) && (tmp_evt->cmnd->device == cmd->device)) {
1715                         if (tmp_evt->cmnd)
1716                                 tmp_evt->cmnd->result = (DID_RESET << 16);
1717                         list_del(&tmp_evt->list);
1718                         unmap_cmd_data(&tmp_evt->iu.srp.cmd, tmp_evt,
1719                                        tmp_evt->hostdata->dev);
1720                         free_event_struct(&tmp_evt->hostdata->pool,
1721                                                    tmp_evt);
1722                         atomic_inc(&hostdata->request_limit);
1723                         if (tmp_evt->cmnd_done)
1724                                 tmp_evt->cmnd_done(tmp_evt->cmnd);
1725                         else if (tmp_evt->done)
1726                                 tmp_evt->done(tmp_evt);
1727                 }
1728         }
1729         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
1730         return SUCCESS;
1731 }
1732
1733 /**
1734  * ibmvscsi_eh_host_reset_handler - Reset the connection to the server
1735  * @cmd:        struct scsi_cmnd having problems
1736 */
1737 static int ibmvscsi_eh_host_reset_handler(struct scsi_cmnd *cmd)
1738 {
1739         unsigned long wait_switch = 0;
1740         struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host);
1741
1742         dev_err(hostdata->dev, "Resetting connection due to error recovery\n");
1743
1744         ibmvscsi_reset_host(hostdata);
1745
1746         for (wait_switch = jiffies + (init_timeout * HZ);
1747              time_before(jiffies, wait_switch) &&
1748                      atomic_read(&hostdata->request_limit) < 2;) {
1749
1750                 msleep(10);
1751         }
1752
1753         if (atomic_read(&hostdata->request_limit) <= 0)
1754                 return FAILED;
1755
1756         return SUCCESS;
1757 }
1758
1759 /**
1760  * ibmvscsi_handle_crq: - Handles and frees received events in the CRQ
1761  * @crq:        Command/Response queue
1762  * @hostdata:   ibmvscsi_host_data of host
1763  *
1764 */
1765 static void ibmvscsi_handle_crq(struct viosrp_crq *crq,
1766                                 struct ibmvscsi_host_data *hostdata)
1767 {
1768         long rc;
1769         unsigned long flags;
1770         /* The hypervisor copies our tag value here so no byteswapping */
1771         struct srp_event_struct *evt_struct =
1772                         (__force struct srp_event_struct *)crq->IU_data_ptr;
1773         switch (crq->valid) {
1774         case VIOSRP_CRQ_INIT_RSP:               /* initialization */
1775                 switch (crq->format) {
1776                 case VIOSRP_CRQ_INIT:   /* Initialization message */
1777                         dev_info(hostdata->dev, "partner initialized\n");
1778                         /* Send back a response */
1779                         rc = ibmvscsi_send_crq(hostdata, 0xC002000000000000LL, 0);
1780                         if (rc == 0) {
1781                                 /* Now login */
1782                                 init_adapter(hostdata);
1783                         } else {
1784                                 dev_err(hostdata->dev, "Unable to send init rsp. rc=%ld\n", rc);
1785                         }
1786
1787                         break;
1788                 case VIOSRP_CRQ_INIT_COMPLETE:  /* Initialization response */
1789                         dev_info(hostdata->dev, "partner initialization complete\n");
1790
1791                         /* Now login */
1792                         init_adapter(hostdata);
1793                         break;
1794                 default:
1795                         dev_err(hostdata->dev, "unknown crq message type: %d\n", crq->format);
1796                 }
1797                 return;
1798         case VIOSRP_CRQ_XPORT_EVENT:    /* Hypervisor telling us the connection is closed */
1799                 scsi_block_requests(hostdata->host);
1800                 ibmvscsi_set_request_limit(hostdata, 0);
1801                 if (crq->format == 0x06) {
1802                         /* We need to re-setup the interpartition connection */
1803                         dev_info(hostdata->dev, "Re-enabling adapter!\n");
1804                         hostdata->client_migrated = 1;
1805                         hostdata->action = IBMVSCSI_HOST_ACTION_REENABLE;
1806                         purge_requests(hostdata, DID_REQUEUE);
1807                         wake_up(&hostdata->work_wait_q);
1808                 } else {
1809                         dev_err(hostdata->dev, "Virtual adapter failed rc %d!\n",
1810                                 crq->format);
1811                         ibmvscsi_reset_host(hostdata);
1812                 }
1813                 return;
1814         case VIOSRP_CRQ_CMD_RSP:                /* real payload */
1815                 break;
1816         default:
1817                 dev_err(hostdata->dev, "got an invalid message type 0x%02x\n",
1818                         crq->valid);
1819                 return;
1820         }
1821
1822         /* The only kind of payload CRQs we should get are responses to
1823          * things we send. Make sure this response is to something we
1824          * actually sent
1825          */
1826         if (!valid_event_struct(&hostdata->pool, evt_struct)) {
1827                 dev_err(hostdata->dev, "returned correlation_token 0x%p is invalid!\n",
1828                        evt_struct);
1829                 return;
1830         }
1831
1832         if (atomic_read(&evt_struct->free)) {
1833                 dev_err(hostdata->dev, "received duplicate correlation_token 0x%p!\n",
1834                         evt_struct);
1835                 return;
1836         }
1837
1838         if (crq->format == VIOSRP_SRP_FORMAT)
1839                 atomic_add(be32_to_cpu(evt_struct->xfer_iu->srp.rsp.req_lim_delta),
1840                            &hostdata->request_limit);
1841
1842         del_timer(&evt_struct->timer);
1843
1844         if ((crq->status != VIOSRP_OK && crq->status != VIOSRP_OK2) && evt_struct->cmnd)
1845                 evt_struct->cmnd->result = DID_ERROR << 16;
1846         if (evt_struct->done)
1847                 evt_struct->done(evt_struct);
1848         else
1849                 dev_err(hostdata->dev, "returned done() is NULL; not running it!\n");
1850
1851         /*
1852          * Lock the host_lock before messing with these structures, since we
1853          * are running in a task context
1854          */
1855         spin_lock_irqsave(evt_struct->hostdata->host->host_lock, flags);
1856         list_del(&evt_struct->list);
1857         free_event_struct(&evt_struct->hostdata->pool, evt_struct);
1858         spin_unlock_irqrestore(evt_struct->hostdata->host->host_lock, flags);
1859 }
1860
1861 /**
1862  * ibmvscsi_slave_configure: Set the "allow_restart" flag for each disk.
1863  * @sdev:       struct scsi_device device to configure
1864  *
1865  * Enable allow_restart for a device if it is a disk.  Adjust the
1866  * queue_depth here also as is required by the documentation for
1867  * struct scsi_host_template.
1868  */
1869 static int ibmvscsi_slave_configure(struct scsi_device *sdev)
1870 {
1871         struct Scsi_Host *shost = sdev->host;
1872         unsigned long lock_flags = 0;
1873
1874         spin_lock_irqsave(shost->host_lock, lock_flags);
1875         if (sdev->type == TYPE_DISK) {
1876                 sdev->allow_restart = 1;
1877                 blk_queue_rq_timeout(sdev->request_queue, 120 * HZ);
1878         }
1879         spin_unlock_irqrestore(shost->host_lock, lock_flags);
1880         return 0;
1881 }
1882
1883 /**
1884  * ibmvscsi_change_queue_depth - Change the device's queue depth
1885  * @sdev:       scsi device struct
1886  * @qdepth:     depth to set
1887  * @reason:     calling context
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 device_attribute *ibmvscsi_attrs[] = {
2069         &ibmvscsi_host_vhost_loc,
2070         &ibmvscsi_host_vhost_name,
2071         &ibmvscsi_host_srp_version,
2072         &ibmvscsi_host_partition_name,
2073         &ibmvscsi_host_partition_number,
2074         &ibmvscsi_host_mad_version,
2075         &ibmvscsi_host_os_type,
2076         &ibmvscsi_host_config,
2077         NULL
2078 };
2079
2080 /* ------------------------------------------------------------
2081  * SCSI driver registration
2082  */
2083 static struct scsi_host_template driver_template = {
2084         .module = THIS_MODULE,
2085         .name = "IBM POWER Virtual SCSI Adapter " IBMVSCSI_VERSION,
2086         .proc_name = "ibmvscsi",
2087         .queuecommand = ibmvscsi_queuecommand,
2088         .eh_timed_out = srp_timed_out,
2089         .eh_abort_handler = ibmvscsi_eh_abort_handler,
2090         .eh_device_reset_handler = ibmvscsi_eh_device_reset_handler,
2091         .eh_host_reset_handler = ibmvscsi_eh_host_reset_handler,
2092         .slave_configure = ibmvscsi_slave_configure,
2093         .change_queue_depth = ibmvscsi_change_queue_depth,
2094         .host_reset = ibmvscsi_host_reset,
2095         .cmd_per_lun = IBMVSCSI_CMDS_PER_LUN_DEFAULT,
2096         .can_queue = IBMVSCSI_MAX_REQUESTS_DEFAULT,
2097         .this_id = -1,
2098         .sg_tablesize = SG_ALL,
2099         .shost_attrs = ibmvscsi_attrs,
2100 };
2101
2102 /**
2103  * ibmvscsi_get_desired_dma - Calculate IO memory desired by the driver
2104  *
2105  * @vdev: struct vio_dev for the device whose desired IO mem is to be returned
2106  *
2107  * Return value:
2108  *      Number of bytes of IO data the driver will need to perform well.
2109  */
2110 static unsigned long ibmvscsi_get_desired_dma(struct vio_dev *vdev)
2111 {
2112         /* iu_storage data allocated in initialize_event_pool */
2113         unsigned long desired_io = max_events * sizeof(union viosrp_iu);
2114
2115         /* add io space for sg data */
2116         desired_io += (IBMVSCSI_MAX_SECTORS_DEFAULT * 512 *
2117                              IBMVSCSI_CMDS_PER_LUN_DEFAULT);
2118
2119         return desired_io;
2120 }
2121
2122 static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata)
2123 {
2124         unsigned long flags;
2125         int rc;
2126         char *action = "reset";
2127
2128         spin_lock_irqsave(hostdata->host->host_lock, flags);
2129         switch (hostdata->action) {
2130         case IBMVSCSI_HOST_ACTION_UNBLOCK:
2131                 rc = 0;
2132                 break;
2133         case IBMVSCSI_HOST_ACTION_RESET:
2134                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2135                 rc = ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata);
2136                 spin_lock_irqsave(hostdata->host->host_lock, flags);
2137                 if (!rc)
2138                         rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
2139                 vio_enable_interrupts(to_vio_dev(hostdata->dev));
2140                 break;
2141         case IBMVSCSI_HOST_ACTION_REENABLE:
2142                 action = "enable";
2143                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2144                 rc = ibmvscsi_reenable_crq_queue(&hostdata->queue, hostdata);
2145                 spin_lock_irqsave(hostdata->host->host_lock, flags);
2146                 if (!rc)
2147                         rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
2148                 break;
2149         case IBMVSCSI_HOST_ACTION_NONE:
2150         default:
2151                 spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2152                 return;
2153         }
2154
2155         hostdata->action = IBMVSCSI_HOST_ACTION_NONE;
2156         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2157
2158         if (rc) {
2159                 ibmvscsi_set_request_limit(hostdata, -1);
2160                 dev_err(hostdata->dev, "error after %s\n", action);
2161         }
2162
2163         scsi_unblock_requests(hostdata->host);
2164 }
2165
2166 static int __ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata)
2167 {
2168         if (kthread_should_stop())
2169                 return 1;
2170         switch (hostdata->action) {
2171         case IBMVSCSI_HOST_ACTION_NONE:
2172                 return 0;
2173         case IBMVSCSI_HOST_ACTION_RESET:
2174         case IBMVSCSI_HOST_ACTION_REENABLE:
2175         case IBMVSCSI_HOST_ACTION_UNBLOCK:
2176         default:
2177                 break;
2178         }
2179
2180         return 1;
2181 }
2182
2183 static int ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata)
2184 {
2185         unsigned long flags;
2186         int rc;
2187
2188         spin_lock_irqsave(hostdata->host->host_lock, flags);
2189         rc = __ibmvscsi_work_to_do(hostdata);
2190         spin_unlock_irqrestore(hostdata->host->host_lock, flags);
2191
2192         return rc;
2193 }
2194
2195 static int ibmvscsi_work(void *data)
2196 {
2197         struct ibmvscsi_host_data *hostdata = data;
2198         int rc;
2199
2200         set_user_nice(current, MIN_NICE);
2201
2202         while (1) {
2203                 rc = wait_event_interruptible(hostdata->work_wait_q,
2204                                               ibmvscsi_work_to_do(hostdata));
2205
2206                 BUG_ON(rc);
2207
2208                 if (kthread_should_stop())
2209                         break;
2210
2211                 ibmvscsi_do_work(hostdata);
2212         }
2213
2214         return 0;
2215 }
2216
2217 /**
2218  * Called by bus code for each adapter
2219  */
2220 static int ibmvscsi_probe(struct vio_dev *vdev, const struct vio_device_id *id)
2221 {
2222         struct ibmvscsi_host_data *hostdata;
2223         struct Scsi_Host *host;
2224         struct device *dev = &vdev->dev;
2225         struct srp_rport_identifiers ids;
2226         struct srp_rport *rport;
2227         unsigned long wait_switch = 0;
2228         int rc;
2229
2230         dev_set_drvdata(&vdev->dev, NULL);
2231
2232         host = scsi_host_alloc(&driver_template, sizeof(*hostdata));
2233         if (!host) {
2234                 dev_err(&vdev->dev, "couldn't allocate host data\n");
2235                 goto scsi_host_alloc_failed;
2236         }
2237
2238         host->transportt = ibmvscsi_transport_template;
2239         hostdata = shost_priv(host);
2240         memset(hostdata, 0x00, sizeof(*hostdata));
2241         INIT_LIST_HEAD(&hostdata->sent);
2242         init_waitqueue_head(&hostdata->work_wait_q);
2243         hostdata->host = host;
2244         hostdata->dev = dev;
2245         ibmvscsi_set_request_limit(hostdata, -1);
2246         hostdata->host->max_sectors = IBMVSCSI_MAX_SECTORS_DEFAULT;
2247
2248         if (map_persist_bufs(hostdata)) {
2249                 dev_err(&vdev->dev, "couldn't map persistent buffers\n");
2250                 goto persist_bufs_failed;
2251         }
2252
2253         hostdata->work_thread = kthread_run(ibmvscsi_work, hostdata, "%s_%d",
2254                                             "ibmvscsi", host->host_no);
2255
2256         if (IS_ERR(hostdata->work_thread)) {
2257                 dev_err(&vdev->dev, "couldn't initialize kthread. rc=%ld\n",
2258                         PTR_ERR(hostdata->work_thread));
2259                 goto init_crq_failed;
2260         }
2261
2262         rc = ibmvscsi_init_crq_queue(&hostdata->queue, hostdata, max_events);
2263         if (rc != 0 && rc != H_RESOURCE) {
2264                 dev_err(&vdev->dev, "couldn't initialize crq. rc=%d\n", rc);
2265                 goto kill_kthread;
2266         }
2267         if (initialize_event_pool(&hostdata->pool, max_events, hostdata) != 0) {
2268                 dev_err(&vdev->dev, "couldn't initialize event pool\n");
2269                 goto init_pool_failed;
2270         }
2271
2272         host->max_lun = IBMVSCSI_MAX_LUN;
2273         host->max_id = max_id;
2274         host->max_channel = max_channel;
2275         host->max_cmd_len = 16;
2276
2277         dev_info(dev,
2278                  "Maximum ID: %d Maximum LUN: %llu Maximum Channel: %d\n",
2279                  host->max_id, host->max_lun, host->max_channel);
2280
2281         if (scsi_add_host(hostdata->host, hostdata->dev))
2282                 goto add_host_failed;
2283
2284         /* we don't have a proper target_port_id so let's use the fake one */
2285         memcpy(ids.port_id, hostdata->madapter_info.partition_name,
2286                sizeof(ids.port_id));
2287         ids.roles = SRP_RPORT_ROLE_TARGET;
2288         rport = srp_rport_add(host, &ids);
2289         if (IS_ERR(rport))
2290                 goto add_srp_port_failed;
2291
2292         /* Try to send an initialization message.  Note that this is allowed
2293          * to fail if the other end is not acive.  In that case we don't
2294          * want to scan
2295          */
2296         if (ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0) == 0
2297             || rc == H_RESOURCE) {
2298                 /*
2299                  * Wait around max init_timeout secs for the adapter to finish
2300                  * initializing. When we are done initializing, we will have a
2301                  * valid request_limit.  We don't want Linux scanning before
2302                  * we are ready.
2303                  */
2304                 for (wait_switch = jiffies + (init_timeout * HZ);
2305                      time_before(jiffies, wait_switch) &&
2306                      atomic_read(&hostdata->request_limit) < 2;) {
2307
2308                         msleep(10);
2309                 }
2310
2311                 /* if we now have a valid request_limit, initiate a scan */
2312                 if (atomic_read(&hostdata->request_limit) > 0)
2313                         scsi_scan_host(host);
2314         }
2315
2316         dev_set_drvdata(&vdev->dev, hostdata);
2317         spin_lock(&ibmvscsi_driver_lock);
2318         list_add_tail(&hostdata->host_list, &ibmvscsi_head);
2319         spin_unlock(&ibmvscsi_driver_lock);
2320         return 0;
2321
2322       add_srp_port_failed:
2323         scsi_remove_host(hostdata->host);
2324       add_host_failed:
2325         release_event_pool(&hostdata->pool, hostdata);
2326       init_pool_failed:
2327         ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, max_events);
2328       kill_kthread:
2329       kthread_stop(hostdata->work_thread);
2330       init_crq_failed:
2331         unmap_persist_bufs(hostdata);
2332       persist_bufs_failed:
2333         scsi_host_put(host);
2334       scsi_host_alloc_failed:
2335         return -1;
2336 }
2337
2338 static int ibmvscsi_remove(struct vio_dev *vdev)
2339 {
2340         struct ibmvscsi_host_data *hostdata = dev_get_drvdata(&vdev->dev);
2341
2342         srp_remove_host(hostdata->host);
2343         scsi_remove_host(hostdata->host);
2344
2345         purge_requests(hostdata, DID_ERROR);
2346         release_event_pool(&hostdata->pool, hostdata);
2347
2348         ibmvscsi_release_crq_queue(&hostdata->queue, hostdata,
2349                                         max_events);
2350
2351         kthread_stop(hostdata->work_thread);
2352         unmap_persist_bufs(hostdata);
2353
2354         spin_lock(&ibmvscsi_driver_lock);
2355         list_del(&hostdata->host_list);
2356         spin_unlock(&ibmvscsi_driver_lock);
2357
2358         scsi_host_put(hostdata->host);
2359
2360         return 0;
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);