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