drivers/scsi/ibmvscsi/ibmvscsi.c

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