drivers/scsi/ibmvscsi/ibmvscsi.c

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

DEFINITIONS
