drivers/block/cciss_scsi.c

   1 /*
   2  *    Disk Array driver for HP Smart Array controllers, SCSI Tape module.
   3  *    (C) Copyright 2001, 2007 Hewlett-Packard Development Company, L.P.
   4  *
   5  *    This program is free software; you can redistribute it and/or modify
   6  *    it under the terms of the GNU General Public License as published by
   7  *    the Free Software Foundation; version 2 of the License.
   8  *
   9  *    This program is distributed in the hope that it will be useful,
  10  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12  *    General Public License for more details.
  13  *
  14  *    You should have received a copy of the GNU General Public License
  15  *    along with this program; if not, write to the Free Software
  16  *    Foundation, Inc., 59 Temple Place, Suite 300, Boston, MA
  17  *    02111-1307, USA.
  18  *
  19  *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
  20  *
  21  *    Author: Stephen M. Cameron
  22  */
  23 #ifdef CONFIG_CISS_SCSI_TAPE
  24
  25 /* Here we have code to present the driver as a scsi driver
  26    as it is simultaneously presented as a block driver.  The
  27    reason for doing this is to allow access to SCSI tape drives
  28    through the array controller.  Note in particular, neither
  29    physical nor logical disks are presented through the scsi layer. */
  30
  31 #include <linux/timer.h>
  32 #include <linux/completion.h>
  33 #include <linux/slab.h>
  34 #include <linux/string.h>
  35
  36 #include <asm/atomic.h>
  37
  38 #include <scsi/scsi_cmnd.h>
  39 #include <scsi/scsi_device.h>
  40 #include <scsi/scsi_host.h>
  41
  42 #include "cciss_scsi.h"
  43
  44 #define CCISS_ABORT_MSG 0x00
  45 #define CCISS_RESET_MSG 0x01
  46
  47 static int fill_cmd(ctlr_info_t *h, CommandList_struct *c, __u8 cmd, void *buff,
  48         size_t size,
  49         __u8 page_code, unsigned char *scsi3addr,
  50         int cmd_type);
  51
  52 static CommandList_struct *cmd_alloc(ctlr_info_t *h);
  53 static CommandList_struct *cmd_special_alloc(ctlr_info_t *h);
  54 static void cmd_free(ctlr_info_t *h, CommandList_struct *c);
  55 static void cmd_special_free(ctlr_info_t *h, CommandList_struct *c);
  56
  57 static int cciss_scsi_proc_info(
  58                 struct Scsi_Host *sh,
  59                 char *buffer, /* data buffer */
  60                 char **start,      /* where data in buffer starts */
  61                 off_t offset,      /* offset from start of imaginary file */
  62                 int length,        /* length of data in buffer */
  63                 int func);         /* 0 == read, 1 == write */
  64
  65 static int cciss_scsi_queue_command (struct Scsi_Host *h,
  66                                      struct scsi_cmnd *cmd);
  67 static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
  68 static int cciss_eh_abort_handler(struct scsi_cmnd *);
  69
  70 static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = {
  71         { .name = "cciss0", .ndevices = 0 },
  72         { .name = "cciss1", .ndevices = 0 },
  73         { .name = "cciss2", .ndevices = 0 },
  74         { .name = "cciss3", .ndevices = 0 },
  75         { .name = "cciss4", .ndevices = 0 },
  76         { .name = "cciss5", .ndevices = 0 },
  77         { .name = "cciss6", .ndevices = 0 },
  78         { .name = "cciss7", .ndevices = 0 },
  79 };
  80
  81 static struct scsi_host_template cciss_driver_template = {
  82         .module                 = THIS_MODULE,
  83         .name                   = "cciss",
  84         .proc_name              = "cciss",
  85         .proc_info              = cciss_scsi_proc_info,
  86         .queuecommand           = cciss_scsi_queue_command,
  87         .can_queue              = SCSI_CCISS_CAN_QUEUE,
  88         .this_id                = 7,
  89         .cmd_per_lun            = 1,
  90         .use_clustering         = DISABLE_CLUSTERING,
  91         /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
  92         .eh_device_reset_handler= cciss_eh_device_reset_handler,
  93         .eh_abort_handler       = cciss_eh_abort_handler,
  94 };
  95
  96 #pragma pack(1)
  97
  98 #define SCSI_PAD_32 8
  99 #define SCSI_PAD_64 8
 100
 101 struct cciss_scsi_cmd_stack_elem_t {
 102         CommandList_struct cmd;
 103         ErrorInfo_struct Err;
 104         __u32 busaddr;
 105         int cmdindex;
 106         u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
 107 };
 108
 109 #pragma pack()
 110
 111 #define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \
 112                 CCISS_MAX_SCSI_DEVS_PER_HBA + 2)
 113                         // plus two for init time usage
 114
 115 #pragma pack(1)
 116 struct cciss_scsi_cmd_stack_t {
 117         struct cciss_scsi_cmd_stack_elem_t *pool;
 118         struct cciss_scsi_cmd_stack_elem_t *elem[CMD_STACK_SIZE];
 119         dma_addr_t cmd_pool_handle;
 120         int top;
 121 };
 122 #pragma pack()
 123
 124 struct cciss_scsi_adapter_data_t {
 125         struct Scsi_Host *scsi_host;
 126         struct cciss_scsi_cmd_stack_t cmd_stack;
 127         SGDescriptor_struct **cmd_sg_list;
 128         int registered;
 129         spinlock_t lock; // to protect ccissscsi[ctlr];
 130 };
 131
 132 #define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \
 133         &h->scsi_ctlr->lock, flags);
 134 #define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \
 135         &h->scsi_ctlr->lock, flags);
 136
 137 static CommandList_struct *
 138 scsi_cmd_alloc(ctlr_info_t *h)
 139 {
 140         /* assume only one process in here at a time, locking done by caller. */
 141         /* use h->lock */
 142         /* might be better to rewrite how we allocate scsi commands in a way that */
 143         /* needs no locking at all. */
 144
 145         /* take the top memory chunk off the stack and return it, if any. */
 146         struct cciss_scsi_cmd_stack_elem_t *c;
 147         struct cciss_scsi_adapter_data_t *sa;
 148         struct cciss_scsi_cmd_stack_t *stk;
 149         u64bit temp64;
 150
 151         sa = h->scsi_ctlr;
 152         stk = &sa->cmd_stack;
 153
 154         if (stk->top < 0)
 155                 return NULL;
 156         c = stk->elem[stk->top];
 157         /* memset(c, 0, sizeof(*c)); */
 158         memset(&c->cmd, 0, sizeof(c->cmd));
 159         memset(&c->Err, 0, sizeof(c->Err));
 160         /* set physical addr of cmd and addr of scsi parameters */
 161         c->cmd.busaddr = c->busaddr;
 162         c->cmd.cmdindex = c->cmdindex;
 163         /* (__u32) (stk->cmd_pool_handle +
 164                 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
 165
 166         temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
 167         /* (__u64) (stk->cmd_pool_handle +
 168                 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
 169                  sizeof(CommandList_struct)); */
 170         stk->top--;
 171         c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
 172         c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
 173         c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
 174
 175         c->cmd.ctlr = h->ctlr;
 176         c->cmd.err_info = &c->Err;
 177
 178         return (CommandList_struct *) c;
 179 }
 180
 181 static void
 182 scsi_cmd_free(ctlr_info_t *h, CommandList_struct *c)
 183 {
 184         /* assume only one process in here at a time, locking done by caller. */
 185         /* use h->lock */
 186         /* drop the free memory chunk on top of the stack. */
 187
 188         struct cciss_scsi_adapter_data_t *sa;
 189         struct cciss_scsi_cmd_stack_t *stk;
 190
 191         sa = h->scsi_ctlr;
 192         stk = &sa->cmd_stack;
 193         stk->top++;
 194         if (stk->top >= CMD_STACK_SIZE) {
 195                 dev_err(&h->pdev->dev,
 196                         "scsi_cmd_free called too many times.\n");
 197                 BUG();
 198         }
 199         stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) c;
 200 }
 201
 202 static int
 203 scsi_cmd_stack_setup(ctlr_info_t *h, struct cciss_scsi_adapter_data_t *sa)
 204 {
 205         int i;
 206         struct cciss_scsi_cmd_stack_t *stk;
 207         size_t size;
 208
 209         sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(h,
 210                 h->chainsize, CMD_STACK_SIZE);
 211         if (!sa->cmd_sg_list && h->chainsize > 0)
 212                 return -ENOMEM;
 213
 214         stk = &sa->cmd_stack;
 215         size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
 216
 217         /* Check alignment, see cciss_cmd.h near CommandList_struct def. */
 218         BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
 219         /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
 220         stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
 221                 pci_alloc_consistent(h->pdev, size, &stk->cmd_pool_handle);
 222
 223         if (stk->pool == NULL) {
 224                 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
 225                 sa->cmd_sg_list = NULL;
 226                 return -ENOMEM;
 227         }
 228
 229         stk->elem = kmalloc(sizeof(stk->elem[0]) * stk->nelems, GFP_KERNEL);
 230         if (!stk->elem) {
 231                 pci_free_consistent(h->pdev, size, stk->pool,
 232                 stk->cmd_pool_handle);
 233                 return -1;
 234         }
 235
 236         for (i=0; i<CMD_STACK_SIZE; i++) {
 237                 stk->elem[i] = &stk->pool[i];
 238                 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
 239                         (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
 240                 stk->elem[i]->cmdindex = i;
 241         }
 242         stk->top = CMD_STACK_SIZE-1;
 243         return 0;
 244 }
 245
 246 static void
 247 scsi_cmd_stack_free(ctlr_info_t *h)
 248 {
 249         struct cciss_scsi_adapter_data_t *sa;
 250         struct cciss_scsi_cmd_stack_t *stk;
 251         size_t size;
 252
 253         sa = h->scsi_ctlr;
 254         stk = &sa->cmd_stack;
 255         if (stk->top != CMD_STACK_SIZE-1) {
 256                 dev_warn(&h->pdev->dev,
 257                         "bug: %d scsi commands are still outstanding.\n",
 258                         CMD_STACK_SIZE - stk->top);
 259         }
 260         size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
 261
 262         pci_free_consistent(h->pdev, size, stk->pool, stk->cmd_pool_handle);
 263         stk->pool = NULL;
 264         cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
 265         kfree(stk->elem);
 266         stk->elem = NULL;
 267 }
 268
 269 #if 0
 270 static int xmargin=8;
 271 static int amargin=60;
 272
 273 static void
 274 print_bytes (unsigned char *c, int len, int hex, int ascii)
 275 {
 276
 277         int i;
 278         unsigned char *x;
 279
 280         if (hex)
 281         {
 282                 x = c;
 283                 for (i=0;i<len;i++)
 284                 {
 285                         if ((i % xmargin) == 0 && i>0) printk("\n");
 286                         if ((i % xmargin) == 0) printk("0x%04x:", i);
 287                         printk(" %02x", *x);
 288                         x++;
 289                 }
 290                 printk("\n");
 291         }
 292         if (ascii)
 293         {
 294                 x = c;
 295                 for (i=0;i<len;i++)
 296                 {
 297                         if ((i % amargin) == 0 && i>0) printk("\n");
 298                         if ((i % amargin) == 0) printk("0x%04x:", i);
 299                         if (*x > 26 && *x < 128) printk("%c", *x);
 300                         else printk(".");
 301                         x++;
 302                 }
 303                 printk("\n");
 304         }
 305 }
 306
 307 static void
 308 print_cmd(CommandList_struct *cp)
 309 {
 310         printk("queue:%d\n", cp->Header.ReplyQueue);
 311         printk("sglist:%d\n", cp->Header.SGList);
 312         printk("sgtot:%d\n", cp->Header.SGTotal);
 313         printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
 314                         cp->Header.Tag.lower);
 315         printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
 316                 cp->Header.LUN.LunAddrBytes[0],
 317                 cp->Header.LUN.LunAddrBytes[1],
 318                 cp->Header.LUN.LunAddrBytes[2],
 319                 cp->Header.LUN.LunAddrBytes[3],
 320                 cp->Header.LUN.LunAddrBytes[4],
 321                 cp->Header.LUN.LunAddrBytes[5],
 322                 cp->Header.LUN.LunAddrBytes[6],
 323                 cp->Header.LUN.LunAddrBytes[7]);
 324         printk("CDBLen:%d\n", cp->Request.CDBLen);
 325         printk("Type:%d\n",cp->Request.Type.Type);
 326         printk("Attr:%d\n",cp->Request.Type.Attribute);
 327         printk(" Dir:%d\n",cp->Request.Type.Direction);
 328         printk("Timeout:%d\n",cp->Request.Timeout);
 329         printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
 330                 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
 331                 cp->Request.CDB[0], cp->Request.CDB[1],
 332                 cp->Request.CDB[2], cp->Request.CDB[3],
 333                 cp->Request.CDB[4], cp->Request.CDB[5],
 334                 cp->Request.CDB[6], cp->Request.CDB[7],
 335                 cp->Request.CDB[8], cp->Request.CDB[9],
 336                 cp->Request.CDB[10], cp->Request.CDB[11],
 337                 cp->Request.CDB[12], cp->Request.CDB[13],
 338                 cp->Request.CDB[14], cp->Request.CDB[15]),
 339         printk("edesc.Addr: 0x%08x/0%08x, Len  = %d\n",
 340                 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
 341                         cp->ErrDesc.Len);
 342         printk("sgs..........Errorinfo:\n");
 343         printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
 344         printk("senselen:%d\n", cp->err_info->SenseLen);
 345         printk("cmd status:%d\n", cp->err_info->CommandStatus);
 346         printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
 347         printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
 348         printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
 349         printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
 350
 351 }
 352
 353 #endif
 354
 355 static int
 356 find_bus_target_lun(ctlr_info_t *h, int *bus, int *target, int *lun)
 357 {
 358         /* finds an unused bus, target, lun for a new device */
 359         /* assumes h->scsi_ctlr->lock is held */
 360         int i, found=0;
 361         unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
 362
 363         memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
 364
 365         target_taken[SELF_SCSI_ID] = 1;
 366         for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++)
 367                 target_taken[ccissscsi[h->ctlr].dev[i].target] = 1;
 368
 369         for (i = 0; i < CCISS_MAX_SCSI_DEVS_PER_HBA; i++) {
 370                 if (!target_taken[i]) {
 371                         *bus = 0; *target=i; *lun = 0; found=1;
 372                         break;
 373                 }
 374         }
 375         return (!found);
 376 }
 377 struct scsi2map {
 378         char scsi3addr[8];
 379         int bus, target, lun;
 380 };
 381
 382 static int
 383 cciss_scsi_add_entry(ctlr_info_t *h, int hostno,
 384                 struct cciss_scsi_dev_t *device,
 385                 struct scsi2map *added, int *nadded)
 386 {
 387         /* assumes h->scsi_ctlr->lock is held */
 388         int n = ccissscsi[h->ctlr].ndevices;
 389         struct cciss_scsi_dev_t *sd;
 390         int i, bus, target, lun;
 391         unsigned char addr1[8], addr2[8];
 392
 393         if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
 394                 dev_warn(&h->pdev->dev, "Too many devices, "
 395                         "some will be inaccessible.\n");
 396                 return -1;
 397         }
 398
 399         bus = target = -1;
 400         lun = 0;
 401         /* Is this device a non-zero lun of a multi-lun device */
 402         /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
 403         if (device->scsi3addr[4] != 0) {
 404                 /* Search through our list and find the device which */
 405                 /* has the same 8 byte LUN address, excepting byte 4. */
 406                 /* Assign the same bus and target for this new LUN. */
 407                 /* Use the logical unit number from the firmware. */
 408                 memcpy(addr1, device->scsi3addr, 8);
 409                 addr1[4] = 0;
 410                 for (i = 0; i < n; i++) {
 411                         sd = &ccissscsi[h->ctlr].dev[i];
 412                         memcpy(addr2, sd->scsi3addr, 8);
 413                         addr2[4] = 0;
 414                         /* differ only in byte 4? */
 415                         if (memcmp(addr1, addr2, 8) == 0) {
 416                                 bus = sd->bus;
 417                                 target = sd->target;
 418                                 lun = device->scsi3addr[4];
 419                                 break;
 420                         }
 421                 }
 422         }
 423
 424         sd = &ccissscsi[h->ctlr].dev[n];
 425         if (lun == 0) {
 426                 if (find_bus_target_lun(h,
 427                         &sd->bus, &sd->target, &sd->lun) != 0)
 428                         return -1;
 429         } else {
 430                 sd->bus = bus;
 431                 sd->target = target;
 432                 sd->lun = lun;
 433         }
 434         added[*nadded].bus = sd->bus;
 435         added[*nadded].target = sd->target;
 436         added[*nadded].lun = sd->lun;
 437         (*nadded)++;
 438
 439         memcpy(sd->scsi3addr, device->scsi3addr, 8);
 440         memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
 441         memcpy(sd->revision, device->revision, sizeof(sd->revision));
 442         memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
 443         sd->devtype = device->devtype;
 444
 445         ccissscsi[h->ctlr].ndevices++;
 446
 447         /* initially, (before registering with scsi layer) we don't
 448            know our hostno and we don't want to print anything first
 449            time anyway (the scsi layer's inquiries will show that info) */
 450         if (hostno != -1)
 451                 dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d added.\n",
 452                         scsi_device_type(sd->devtype), hostno,
 453                         sd->bus, sd->target, sd->lun);
 454         return 0;
 455 }
 456
 457 static void
 458 cciss_scsi_remove_entry(ctlr_info_t *h, int hostno, int entry,
 459         struct scsi2map *removed, int *nremoved)
 460 {
 461         /* assumes h->ctlr]->scsi_ctlr->lock is held */
 462         int i;
 463         struct cciss_scsi_dev_t sd;
 464
 465         if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
 466         sd = ccissscsi[h->ctlr].dev[entry];
 467         removed[*nremoved].bus    = sd.bus;
 468         removed[*nremoved].target = sd.target;
 469         removed[*nremoved].lun    = sd.lun;
 470         (*nremoved)++;
 471         for (i = entry; i < ccissscsi[h->ctlr].ndevices-1; i++)
 472                 ccissscsi[h->ctlr].dev[i] = ccissscsi[h->ctlr].dev[i+1];
 473         ccissscsi[h->ctlr].ndevices--;
 474         dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d removed.\n",
 475                 scsi_device_type(sd.devtype), hostno,
 476                         sd.bus, sd.target, sd.lun);
 477 }
 478
 479
 480 #define SCSI3ADDR_EQ(a,b) ( \
 481         (a)[7] == (b)[7] && \
 482         (a)[6] == (b)[6] && \
 483         (a)[5] == (b)[5] && \
 484         (a)[4] == (b)[4] && \
 485         (a)[3] == (b)[3] && \
 486         (a)[2] == (b)[2] && \
 487         (a)[1] == (b)[1] && \
 488         (a)[0] == (b)[0])
 489
 490 static void fixup_botched_add(ctlr_info_t *h, char *scsi3addr)
 491 {
 492         /* called when scsi_add_device fails in order to re-adjust */
 493         /* ccissscsi[] to match the mid layer's view. */
 494         unsigned long flags;
 495         int i, j;
 496         CPQ_TAPE_LOCK(h, flags);
 497         for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
 498                 if (memcmp(scsi3addr,
 499                                 ccissscsi[h->ctlr].dev[i].scsi3addr, 8) == 0) {
 500                         for (j = i; j < ccissscsi[h->ctlr].ndevices-1; j++)
 501                                 ccissscsi[h->ctlr].dev[j] =
 502                                         ccissscsi[h->ctlr].dev[j+1];
 503                         ccissscsi[h->ctlr].ndevices--;
 504                         break;
 505                 }
 506         }
 507         CPQ_TAPE_UNLOCK(h, flags);
 508 }
 509
 510 static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
 511         struct cciss_scsi_dev_t *dev2)
 512 {
 513         return dev1->devtype == dev2->devtype &&
 514                 memcmp(dev1->scsi3addr, dev2->scsi3addr,
 515                         sizeof(dev1->scsi3addr)) == 0 &&
 516                 memcmp(dev1->device_id, dev2->device_id,
 517                         sizeof(dev1->device_id)) == 0 &&
 518                 memcmp(dev1->vendor, dev2->vendor,
 519                         sizeof(dev1->vendor)) == 0 &&
 520                 memcmp(dev1->model, dev2->model,
 521                         sizeof(dev1->model)) == 0 &&
 522                 memcmp(dev1->revision, dev2->revision,
 523                         sizeof(dev1->revision)) == 0;
 524 }
 525
 526 static int
 527 adjust_cciss_scsi_table(ctlr_info_t *h, int hostno,
 528         struct cciss_scsi_dev_t sd[], int nsds)
 529 {
 530         /* sd contains scsi3 addresses and devtypes, but
 531            bus target and lun are not filled in.  This funciton
 532            takes what's in sd to be the current and adjusts
 533            ccissscsi[] to be in line with what's in sd. */
 534
 535         int i,j, found, changes=0;
 536         struct cciss_scsi_dev_t *csd;
 537         unsigned long flags;
 538         struct scsi2map *added, *removed;
 539         int nadded, nremoved;
 540         struct Scsi_Host *sh = NULL;
 541
 542         added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
 543                         GFP_KERNEL);
 544         removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
 545                         GFP_KERNEL);
 546
 547         if (!added || !removed) {
 548                 dev_warn(&h->pdev->dev,
 549                         "Out of memory in adjust_cciss_scsi_table\n");
 550                 goto free_and_out;
 551         }
 552
 553         CPQ_TAPE_LOCK(h, flags);
 554
 555         if (hostno != -1)  /* if it's not the first time... */
 556                 sh = h->scsi_ctlr->scsi_host;
 557
 558         /* find any devices in ccissscsi[] that are not in
 559            sd[] and remove them from ccissscsi[] */
 560
 561         i = 0;
 562         nremoved = 0;
 563         nadded = 0;
 564         while (i < ccissscsi[h->ctlr].ndevices) {
 565                 csd = &ccissscsi[h->ctlr].dev[i];
 566                 found=0;
 567                 for (j=0;j<nsds;j++) {
 568                         if (SCSI3ADDR_EQ(sd[j].scsi3addr,
 569                                 csd->scsi3addr)) {
 570                                 if (device_is_the_same(&sd[j], csd))
 571                                         found=2;
 572                                 else
 573                                         found=1;
 574                                 break;
 575                         }
 576                 }
 577
 578                 if (found == 0) { /* device no longer present. */
 579                         changes++;
 580                         cciss_scsi_remove_entry(h, hostno, i,
 581                                 removed, &nremoved);
 582                         /* remove ^^^, hence i not incremented */
 583                 } else if (found == 1) { /* device is different in some way */
 584                         changes++;
 585                         dev_info(&h->pdev->dev,
 586                                 "device c%db%dt%dl%d has changed.\n",
 587                                 hostno, csd->bus, csd->target, csd->lun);
 588                         cciss_scsi_remove_entry(h, hostno, i,
 589                                 removed, &nremoved);
 590                         /* remove ^^^, hence i not incremented */
 591                         if (cciss_scsi_add_entry(h, hostno, &sd[j],
 592                                 added, &nadded) != 0)
 593                                 /* we just removed one, so add can't fail. */
 594                                         BUG();
 595                         csd->devtype = sd[j].devtype;
 596                         memcpy(csd->device_id, sd[j].device_id,
 597                                 sizeof(csd->device_id));
 598                         memcpy(csd->vendor, sd[j].vendor,
 599                                 sizeof(csd->vendor));
 600                         memcpy(csd->model, sd[j].model,
 601                                 sizeof(csd->model));
 602                         memcpy(csd->revision, sd[j].revision,
 603                                 sizeof(csd->revision));
 604                 } else          /* device is same as it ever was, */
 605                         i++;    /* so just move along. */
 606         }
 607
 608         /* Now, make sure every device listed in sd[] is also
 609            listed in ccissscsi[], adding them if they aren't found */
 610
 611         for (i=0;i<nsds;i++) {
 612                 found=0;
 613                 for (j = 0; j < ccissscsi[h->ctlr].ndevices; j++) {
 614                         csd = &ccissscsi[h->ctlr].dev[j];
 615                         if (SCSI3ADDR_EQ(sd[i].scsi3addr,
 616                                 csd->scsi3addr)) {
 617                                 if (device_is_the_same(&sd[i], csd))
 618                                         found=2;        /* found device */
 619                                 else
 620                                         found=1;        /* found a bug. */
 621                                 break;
 622                         }
 623                 }
 624                 if (!found) {
 625                         changes++;
 626                         if (cciss_scsi_add_entry(h, hostno, &sd[i],
 627                                 added, &nadded) != 0)
 628                                 break;
 629                 } else if (found == 1) {
 630                         /* should never happen... */
 631                         changes++;
 632                         dev_warn(&h->pdev->dev,
 633                                 "device unexpectedly changed\n");
 634                         /* but if it does happen, we just ignore that device */
 635                 }
 636         }
 637         CPQ_TAPE_UNLOCK(h, flags);
 638
 639         /* Don't notify scsi mid layer of any changes the first time through */
 640         /* (or if there are no changes) scsi_scan_host will do it later the */
 641         /* first time through. */
 642         if (hostno == -1 || !changes)
 643                 goto free_and_out;
 644
 645         /* Notify scsi mid layer of any removed devices */
 646         for (i = 0; i < nremoved; i++) {
 647                 struct scsi_device *sdev =
 648                         scsi_device_lookup(sh, removed[i].bus,
 649                                 removed[i].target, removed[i].lun);
 650                 if (sdev != NULL) {
 651                         scsi_remove_device(sdev);
 652                         scsi_device_put(sdev);
 653                 } else {
 654                         /* We don't expect to get here. */
 655                         /* future cmds to this device will get selection */
 656                         /* timeout as if the device was gone. */
 657                         dev_warn(&h->pdev->dev, "didn't find "
 658                                 "c%db%dt%dl%d\n for removal.",
 659                                 hostno, removed[i].bus,
 660                                 removed[i].target, removed[i].lun);
 661                 }
 662         }
 663
 664         /* Notify scsi mid layer of any added devices */
 665         for (i = 0; i < nadded; i++) {
 666                 int rc;
 667                 rc = scsi_add_device(sh, added[i].bus,
 668                         added[i].target, added[i].lun);
 669                 if (rc == 0)
 670                         continue;
 671                 dev_warn(&h->pdev->dev, "scsi_add_device "
 672                         "c%db%dt%dl%d failed, device not added.\n",
 673                         hostno, added[i].bus, added[i].target, added[i].lun);
 674                 /* now we have to remove it from ccissscsi, */
 675                 /* since it didn't get added to scsi mid layer */
 676                 fixup_botched_add(h, added[i].scsi3addr);
 677         }
 678
 679 free_and_out:
 680         kfree(added);
 681         kfree(removed);
 682         return 0;
 683 }
 684
 685 static int
 686 lookup_scsi3addr(ctlr_info_t *h, int bus, int target, int lun, char *scsi3addr)
 687 {
 688         int i;
 689         struct cciss_scsi_dev_t *sd;
 690         unsigned long flags;
 691
 692         CPQ_TAPE_LOCK(h, flags);
 693         for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
 694                 sd = &ccissscsi[h->ctlr].dev[i];
 695                 if (sd->bus == bus &&
 696                     sd->target == target &&
 697                     sd->lun == lun) {
 698                         memcpy(scsi3addr, &sd->scsi3addr[0], 8);
 699                         CPQ_TAPE_UNLOCK(h, flags);
 700                         return 0;
 701                 }
 702         }
 703         CPQ_TAPE_UNLOCK(h, flags);
 704         return -1;
 705 }
 706
 707 static void
 708 cciss_scsi_setup(ctlr_info_t *h)
 709 {
 710         struct cciss_scsi_adapter_data_t * shba;
 711
 712         ccissscsi[h->ctlr].ndevices = 0;
 713         shba = (struct cciss_scsi_adapter_data_t *)
 714                 kmalloc(sizeof(*shba), GFP_KERNEL);
 715         if (shba == NULL)
 716                 return;
 717         shba->scsi_host = NULL;
 718         spin_lock_init(&shba->lock);
 719         shba->registered = 0;
 720         if (scsi_cmd_stack_setup(h, shba) != 0) {
 721                 kfree(shba);
 722                 shba = NULL;
 723         }
 724         h->scsi_ctlr = shba;
 725         return;
 726 }
 727
 728 static void complete_scsi_command(CommandList_struct *c, int timeout,
 729         __u32 tag)
 730 {
 731         struct scsi_cmnd *cmd;
 732         ctlr_info_t *h;
 733         ErrorInfo_struct *ei;
 734
 735         ei = c->err_info;
 736
 737         /* First, see if it was a message rather than a command */
 738         if (c->Request.Type.Type == TYPE_MSG)  {
 739                 c->cmd_type = CMD_MSG_DONE;
 740                 return;
 741         }
 742
 743         cmd = (struct scsi_cmnd *) c->scsi_cmd;
 744         h = hba[c->ctlr];
 745
 746         scsi_dma_unmap(cmd);
 747         if (c->Header.SGTotal > h->max_cmd_sgentries)
 748                 cciss_unmap_sg_chain_block(h, c);
 749
 750         cmd->result = (DID_OK << 16);           /* host byte */
 751         cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
 752         /* cmd->result |= (GOOD < 1); */                /* status byte */
 753
 754         cmd->result |= (ei->ScsiStatus);
 755         /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus);  */
 756
 757         /* copy the sense data whether we need to or not. */
 758
 759         memcpy(cmd->sense_buffer, ei->SenseInfo,
 760                 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
 761                         SCSI_SENSE_BUFFERSIZE :
 762                         ei->SenseLen);
 763         scsi_set_resid(cmd, ei->ResidualCnt);
 764
 765         if(ei->CommandStatus != 0)
 766         { /* an error has occurred */
 767                 switch(ei->CommandStatus)
 768                 {
 769                         case CMD_TARGET_STATUS:
 770                                 /* Pass it up to the upper layers... */
 771                                 if( ei->ScsiStatus)
 772                                 {
 773 #if 0
 774                                         printk(KERN_WARNING "cciss: cmd %p "
 775                                                 "has SCSI Status = %x\n",
 776                                                 c, ei->ScsiStatus);
 777 #endif
 778                                         cmd->result |= (ei->ScsiStatus << 1);
 779                                 }
 780                                 else {  /* scsi status is zero??? How??? */
 781
 782         /* Ordinarily, this case should never happen, but there is a bug
 783            in some released firmware revisions that allows it to happen
 784            if, for example, a 4100 backplane loses power and the tape
 785            drive is in it.  We assume that it's a fatal error of some
 786            kind because we can't show that it wasn't. We will make it
 787            look like selection timeout since that is the most common
 788            reason for this to occur, and it's severe enough. */
 789
 790                                         cmd->result = DID_NO_CONNECT << 16;
 791                                 }
 792                         break;
 793                         case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
 794                         break;
 795                         case CMD_DATA_OVERRUN:
 796                                 dev_warn(&h->pdev->dev, "%p has"
 797                                         " completed with data overrun "
 798                                         "reported\n", c);
 799                         break;
 800                         case CMD_INVALID: {
 801                                 /* print_bytes(c, sizeof(*c), 1, 0);
 802                                 print_cmd(c); */
 803      /* We get CMD_INVALID if you address a non-existent tape drive instead
 804         of a selection timeout (no response).  You will see this if you yank
 805         out a tape drive, then try to access it. This is kind of a shame
 806         because it means that any other CMD_INVALID (e.g. driver bug) will
 807         get interpreted as a missing target. */
 808                                 cmd->result = DID_NO_CONNECT << 16;
 809                                 }
 810                         break;
 811                         case CMD_PROTOCOL_ERR:
 812                                 dev_warn(&h->pdev->dev,
 813                                         "%p has protocol error\n", c);
 814                         break;
 815                         case CMD_HARDWARE_ERR:
 816                                 cmd->result = DID_ERROR << 16;
 817                                 dev_warn(&h->pdev->dev,
 818                                         "%p had hardware error\n", c);
 819                         break;
 820                         case CMD_CONNECTION_LOST:
 821                                 cmd->result = DID_ERROR << 16;
 822                                 dev_warn(&h->pdev->dev,
 823                                         "%p had connection lost\n", c);
 824                         break;
 825                         case CMD_ABORTED:
 826                                 cmd->result = DID_ABORT << 16;
 827                                 dev_warn(&h->pdev->dev, "%p was aborted\n", c);
 828                         break;
 829                         case CMD_ABORT_FAILED:
 830                                 cmd->result = DID_ERROR << 16;
 831                                 dev_warn(&h->pdev->dev,
 832                                         "%p reports abort failed\n", c);
 833                         break;
 834                         case CMD_UNSOLICITED_ABORT:
 835                                 cmd->result = DID_ABORT << 16;
 836                                 dev_warn(&h->pdev->dev, "%p aborted due to an "
 837                                         "unsolicited abort\n", c);
 838                         break;
 839                         case CMD_TIMEOUT:
 840                                 cmd->result = DID_TIME_OUT << 16;
 841                                 dev_warn(&h->pdev->dev, "%p timedout\n", c);
 842                         break;
 843                         case CMD_UNABORTABLE:
 844                                 cmd->result = DID_ERROR << 16;
 845                                 dev_warn(&h->pdev->dev, "c %p command "
 846                                         "unabortable\n", c);
 847                         break;
 848                         default:
 849                                 cmd->result = DID_ERROR << 16;
 850                                 dev_warn(&h->pdev->dev,
 851                                         "%p returned unknown status %x\n", c,
 852                                                 ei->CommandStatus);
 853                 }
 854         }
 855         cmd->scsi_done(cmd);
 856         scsi_cmd_free(h, c);
 857 }
 858
 859 static int
 860 cciss_scsi_detect(ctlr_info_t *h)
 861 {
 862         struct Scsi_Host *sh;
 863         int error;
 864
 865         sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
 866         if (sh == NULL)
 867                 goto fail;
 868         sh->io_port = 0;        // good enough?  FIXME,
 869         sh->n_io_port = 0;      // I don't think we use these two...
 870         sh->this_id = SELF_SCSI_ID;
 871         sh->sg_tablesize = h->maxsgentries;
 872         sh->max_cmd_len = MAX_COMMAND_SIZE;
 873
 874         ((struct cciss_scsi_adapter_data_t *)
 875                 h->scsi_ctlr)->scsi_host = sh;
 876         sh->hostdata[0] = (unsigned long) h;
 877         sh->irq = h->intr[SIMPLE_MODE_INT];
 878         sh->unique_id = sh->irq;
 879         error = scsi_add_host(sh, &h->pdev->dev);
 880         if (error)
 881                 goto fail_host_put;
 882         scsi_scan_host(sh);
 883         return 1;
 884
 885  fail_host_put:
 886         scsi_host_put(sh);
 887  fail:
 888         return 0;
 889 }
 890
 891 static void
 892 cciss_unmap_one(struct pci_dev *pdev,
 893                 CommandList_struct *c,
 894                 size_t buflen,
 895                 int data_direction)
 896 {
 897         u64bit addr64;
 898
 899         addr64.val32.lower = c->SG[0].Addr.lower;
 900         addr64.val32.upper = c->SG[0].Addr.upper;
 901         pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
 902 }
 903
 904 static void
 905 cciss_map_one(struct pci_dev *pdev,
 906                 CommandList_struct *c,
 907                 unsigned char *buf,
 908                 size_t buflen,
 909                 int data_direction)
 910 {
 911         __u64 addr64;
 912
 913         addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
 914         c->SG[0].Addr.lower =
 915           (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
 916         c->SG[0].Addr.upper =
 917           (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
 918         c->SG[0].Len = buflen;
 919         c->Header.SGList = (__u8) 1;   /* no. SGs contig in this cmd */
 920         c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
 921 }
 922
 923 static int
 924 cciss_scsi_do_simple_cmd(ctlr_info_t *h,
 925                         CommandList_struct *c,
 926                         unsigned char *scsi3addr,
 927                         unsigned char *cdb,
 928                         unsigned char cdblen,
 929                         unsigned char *buf, int bufsize,
 930                         int direction)
 931 {
 932         DECLARE_COMPLETION_ONSTACK(wait);
 933
 934         c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */
 935         c->scsi_cmd = NULL;
 936         c->Header.ReplyQueue = 0;  /* unused in simple mode */
 937         memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN));
 938         c->Header.Tag.lower = c->busaddr;  /* Use k. address of cmd as tag */
 939         // Fill in the request block...
 940
 941         /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
 942                 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
 943                 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
 944
 945         memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
 946         memcpy(c->Request.CDB, cdb, cdblen);
 947         c->Request.Timeout = 0;
 948         c->Request.CDBLen = cdblen;
 949         c->Request.Type.Type = TYPE_CMD;
 950         c->Request.Type.Attribute = ATTR_SIMPLE;
 951         c->Request.Type.Direction = direction;
 952
 953         /* Fill in the SG list and do dma mapping */
 954         cciss_map_one(h->pdev, c, (unsigned char *) buf,
 955                         bufsize, DMA_FROM_DEVICE);
 956
 957         c->waiting = &wait;
 958         enqueue_cmd_and_start_io(h, c);
 959         wait_for_completion(&wait);
 960
 961         /* undo the dma mapping */
 962         cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE);
 963         return(0);
 964 }
 965
 966 static void
 967 cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c)
 968 {
 969         ErrorInfo_struct *ei;
 970
 971         ei = c->err_info;
 972         switch(ei->CommandStatus)
 973         {
 974                 case CMD_TARGET_STATUS:
 975                         dev_warn(&h->pdev->dev,
 976                                 "cmd %p has completed with errors\n", c);
 977                         dev_warn(&h->pdev->dev,
 978                                 "cmd %p has SCSI Status = %x\n",
 979                                 c, ei->ScsiStatus);
 980                         if (ei->ScsiStatus == 0)
 981                                 dev_warn(&h->pdev->dev,
 982                                 "SCSI status is abnormally zero.  "
 983                                 "(probably indicates selection timeout "
 984                                 "reported incorrectly due to a known "
 985                                 "firmware bug, circa July, 2001.)\n");
 986                 break;
 987                 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
 988                         dev_info(&h->pdev->dev, "UNDERRUN\n");
 989                 break;
 990                 case CMD_DATA_OVERRUN:
 991                         dev_warn(&h->pdev->dev, "%p has"
 992                                 " completed with data overrun "
 993                                 "reported\n", c);
 994                 break;
 995                 case CMD_INVALID: {
 996                         /* controller unfortunately reports SCSI passthru's */
 997                         /* to non-existent targets as invalid commands. */
 998                         dev_warn(&h->pdev->dev,
 999                                 "%p is reported invalid (probably means "
1000                                 "target device no longer present)\n", c);
1001                         /* print_bytes((unsigned char *) c, sizeof(*c), 1, 0);
1002                         print_cmd(c);  */
1003                         }
1004                 break;
1005                 case CMD_PROTOCOL_ERR:
1006                         dev_warn(&h->pdev->dev, "%p has protocol error\n", c);
1007                 break;
1008                 case CMD_HARDWARE_ERR:
1009                         /* cmd->result = DID_ERROR << 16; */
1010                         dev_warn(&h->pdev->dev, "%p had hardware error\n", c);
1011                 break;
1012                 case CMD_CONNECTION_LOST:
1013                         dev_warn(&h->pdev->dev, "%p had connection lost\n", c);
1014                 break;
1015                 case CMD_ABORTED:
1016                         dev_warn(&h->pdev->dev, "%p was aborted\n", c);
1017                 break;
1018                 case CMD_ABORT_FAILED:
1019                         dev_warn(&h->pdev->dev,
1020                                 "%p reports abort failed\n", c);
1021                 break;
1022                 case CMD_UNSOLICITED_ABORT:
1023                         dev_warn(&h->pdev->dev,
1024                                 "%p aborted due to an unsolicited abort\n", c);
1025                 break;
1026                 case CMD_TIMEOUT:
1027                         dev_warn(&h->pdev->dev, "%p timedout\n", c);
1028                 break;
1029                 case CMD_UNABORTABLE:
1030                         dev_warn(&h->pdev->dev,
1031                                 "%p unabortable\n", c);
1032                 break;
1033                 default:
1034                         dev_warn(&h->pdev->dev,
1035                                 "%p returned unknown status %x\n",
1036                                 c, ei->CommandStatus);
1037         }
1038 }
1039
1040 static int
1041 cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr,
1042         unsigned char page, unsigned char *buf,
1043         unsigned char bufsize)
1044 {
1045         int rc;
1046         CommandList_struct *c;
1047         char cdb[6];
1048         ErrorInfo_struct *ei;
1049         unsigned long flags;
1050
1051         spin_lock_irqsave(&h->lock, flags);
1052         c = scsi_cmd_alloc(h);
1053         spin_unlock_irqrestore(&h->lock, flags);
1054
1055         if (c == NULL) {                        /* trouble... */
1056                 printk("cmd_alloc returned NULL!\n");
1057                 return -1;
1058         }
1059
1060         ei = c->err_info;
1061
1062         cdb[0] = CISS_INQUIRY;
1063         cdb[1] = (page != 0);
1064         cdb[2] = page;
1065         cdb[3] = 0;
1066         cdb[4] = bufsize;
1067         cdb[5] = 0;
1068         rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb,
1069                                 6, buf, bufsize, XFER_READ);
1070
1071         if (rc != 0) return rc; /* something went wrong */
1072
1073         if (ei->CommandStatus != 0 &&
1074             ei->CommandStatus != CMD_DATA_UNDERRUN) {
1075                 cciss_scsi_interpret_error(h, c);
1076                 rc = -1;
1077         }
1078         spin_lock_irqsave(&h->lock, flags);
1079         scsi_cmd_free(h, c);
1080         spin_unlock_irqrestore(&h->lock, flags);
1081         return rc;
1082 }
1083
1084 /* Get the device id from inquiry page 0x83 */
1085 static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr,
1086         unsigned char *device_id, int buflen)
1087 {
1088         int rc;
1089         unsigned char *buf;
1090
1091         if (buflen > 16)
1092                 buflen = 16;
1093         buf = kzalloc(64, GFP_KERNEL);
1094         if (!buf)
1095                 return -1;
1096         rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
1097         if (rc == 0)
1098                 memcpy(device_id, &buf[8], buflen);
1099         kfree(buf);
1100         return rc != 0;
1101 }
1102
1103 static int
1104 cciss_scsi_do_report_phys_luns(ctlr_info_t *h,
1105                 ReportLunData_struct *buf, int bufsize)
1106 {
1107         int rc;
1108         CommandList_struct *c;
1109         unsigned char cdb[12];
1110         unsigned char scsi3addr[8];
1111         ErrorInfo_struct *ei;
1112         unsigned long flags;
1113
1114         spin_lock_irqsave(&h->lock, flags);
1115         c = scsi_cmd_alloc(h);
1116         spin_unlock_irqrestore(&h->lock, flags);
1117         if (c == NULL) {                        /* trouble... */
1118                 printk("cmd_alloc returned NULL!\n");
1119                 return -1;
1120         }
1121
1122         memset(&scsi3addr[0], 0, 8); /* address the controller */
1123         cdb[0] = CISS_REPORT_PHYS;
1124         cdb[1] = 0;
1125         cdb[2] = 0;
1126         cdb[3] = 0;
1127         cdb[4] = 0;
1128         cdb[5] = 0;
1129         cdb[6] = (bufsize >> 24) & 0xFF;  //MSB
1130         cdb[7] = (bufsize >> 16) & 0xFF;
1131         cdb[8] = (bufsize >> 8) & 0xFF;
1132         cdb[9] = bufsize & 0xFF;
1133         cdb[10] = 0;
1134         cdb[11] = 0;
1135
1136         rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr,
1137                                 cdb, 12,
1138                                 (unsigned char *) buf,
1139                                 bufsize, XFER_READ);
1140
1141         if (rc != 0) return rc; /* something went wrong */
1142
1143         ei = c->err_info;
1144         if (ei->CommandStatus != 0 &&
1145             ei->CommandStatus != CMD_DATA_UNDERRUN) {
1146                 cciss_scsi_interpret_error(h, c);
1147                 rc = -1;
1148         }
1149         spin_lock_irqsave(&h->lock, flags);
1150         scsi_cmd_free(h, c);
1151         spin_unlock_irqrestore(&h->lock, flags);
1152         return rc;
1153 }
1154
1155 static void
1156 cciss_update_non_disk_devices(ctlr_info_t *h, int hostno)
1157 {
1158         /* the idea here is we could get notified from /proc
1159            that some devices have changed, so we do a report
1160            physical luns cmd, and adjust our list of devices
1161            accordingly.  (We can't rely on the scsi-mid layer just
1162            doing inquiries, because the "busses" that the scsi
1163            mid-layer probes are totally fabricated by this driver,
1164            so new devices wouldn't show up.
1165
1166            the scsi3addr's of devices won't change so long as the
1167            adapter is not reset.  That means we can rescan and
1168            tell which devices we already know about, vs. new
1169            devices, vs.  disappearing devices.
1170
1171            Also, if you yank out a tape drive, then put in a disk
1172            in it's place, (say, a configured volume from another
1173            array controller for instance)  _don't_ poke this driver
1174            (so it thinks it's still a tape, but _do_ poke the scsi
1175            mid layer, so it does an inquiry... the scsi mid layer
1176            will see the physical disk.  This would be bad.  Need to
1177            think about how to prevent that.  One idea would be to
1178            snoop all scsi responses and if an inquiry repsonse comes
1179            back that reports a disk, chuck it an return selection
1180            timeout instead and adjust our table...  Not sure i like
1181            that though.
1182
1183          */
1184 #define OBDR_TAPE_INQ_SIZE 49
1185 #define OBDR_TAPE_SIG "$DR-10"
1186         ReportLunData_struct *ld_buff;
1187         unsigned char *inq_buff;
1188         unsigned char scsi3addr[8];
1189         __u32 num_luns=0;
1190         unsigned char *ch;
1191         struct cciss_scsi_dev_t *currentsd, *this_device;
1192         int ncurrent=0;
1193         int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1194         int i;
1195
1196         ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1197         inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1198         currentsd = kzalloc(sizeof(*currentsd) *
1199                         (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1200         if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1201                 printk(KERN_ERR "cciss: out of memory\n");
1202                 goto out;
1203         }
1204         this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1205         if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) {
1206                 ch = &ld_buff->LUNListLength[0];
1207                 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1208                 if (num_luns > CISS_MAX_PHYS_LUN) {
1209                         printk(KERN_WARNING
1210                                 "cciss: Maximum physical LUNs (%d) exceeded.  "
1211                                 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1212                                 num_luns - CISS_MAX_PHYS_LUN);
1213                         num_luns = CISS_MAX_PHYS_LUN;
1214                 }
1215         }
1216         else {
1217                 printk(KERN_ERR  "cciss: Report physical LUNs failed.\n");
1218                 goto out;
1219         }
1220
1221
1222         /* adjust our table of devices */
1223         for (i = 0; i < num_luns; i++) {
1224                 /* for each physical lun, do an inquiry */
1225                 if (ld_buff->LUN[i][3] & 0xC0) continue;
1226                 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1227                 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1228
1229                 if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
1230                         (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1231                         /* Inquiry failed (msg printed already) */
1232                         continue; /* so we will skip this device. */
1233
1234                 this_device->devtype = (inq_buff[0] & 0x1f);
1235                 this_device->bus = -1;
1236                 this_device->target = -1;
1237                 this_device->lun = -1;
1238                 memcpy(this_device->scsi3addr, scsi3addr, 8);
1239                 memcpy(this_device->vendor, &inq_buff[8],
1240                         sizeof(this_device->vendor));
1241                 memcpy(this_device->model, &inq_buff[16],
1242                         sizeof(this_device->model));
1243                 memcpy(this_device->revision, &inq_buff[32],
1244                         sizeof(this_device->revision));
1245                 memset(this_device->device_id, 0,
1246                         sizeof(this_device->device_id));
1247                 cciss_scsi_get_device_id(h, scsi3addr,
1248                         this_device->device_id, sizeof(this_device->device_id));
1249
1250                 switch (this_device->devtype)
1251                 {
1252                   case 0x05: /* CD-ROM */ {
1253
1254                         /* We don't *really* support actual CD-ROM devices,
1255                          * just this "One Button Disaster Recovery" tape drive
1256                          * which temporarily pretends to be a CD-ROM drive.
1257                          * So we check that the device is really an OBDR tape
1258                          * device by checking for "$DR-10" in bytes 43-48 of
1259                          * the inquiry data.
1260                          */
1261                                 char obdr_sig[7];
1262
1263                                 strncpy(obdr_sig, &inq_buff[43], 6);
1264                                 obdr_sig[6] = '\0';
1265                                 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1266                                         /* Not OBDR device, ignore it. */
1267                                         break;
1268                         }
1269                         /* fall through . . . */
1270                   case 0x01: /* sequential access, (tape) */
1271                   case 0x08: /* medium changer */
1272                         if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1273                                 printk(KERN_INFO "cciss%d: %s ignored, "
1274                                         "too many devices.\n", h->ctlr,
1275                                         scsi_device_type(this_device->devtype));
1276                                 break;
1277                         }
1278                         currentsd[ncurrent] = *this_device;
1279                         ncurrent++;
1280                         break;
1281                   default:
1282                         break;
1283                 }
1284         }
1285
1286         adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent);
1287 out:
1288         kfree(inq_buff);
1289         kfree(ld_buff);
1290         kfree(currentsd);
1291         return;
1292 }
1293
1294 static int
1295 is_keyword(char *ptr, int len, char *verb)  // Thanks to ncr53c8xx.c
1296 {
1297         int verb_len = strlen(verb);
1298         if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1299                 return verb_len;
1300         else
1301                 return 0;
1302 }
1303
1304 static int
1305 cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length)
1306 {
1307         int arg_len;
1308
1309         if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1310                 cciss_update_non_disk_devices(h, hostno);
1311         else
1312                 return -EINVAL;
1313         return length;
1314 }
1315
1316
1317 static int
1318 cciss_scsi_proc_info(struct Scsi_Host *sh,
1319                 char *buffer, /* data buffer */
1320                 char **start,      /* where data in buffer starts */
1321                 off_t offset,      /* offset from start of imaginary file */
1322                 int length,        /* length of data in buffer */
1323                 int func)          /* 0 == read, 1 == write */
1324 {
1325
1326         int buflen, datalen;
1327         ctlr_info_t *h;
1328         int i;
1329
1330         h = (ctlr_info_t *) sh->hostdata[0];
1331         if (h == NULL)  /* This really shouldn't ever happen. */
1332                 return -EINVAL;
1333
1334         if (func == 0) {        /* User is reading from /proc/scsi/ciss*?/?*  */
1335                 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1336                                 h->ctlr, sh->host_no);
1337
1338                 /* this information is needed by apps to know which cciss
1339                    device corresponds to which scsi host number without
1340                    having to open a scsi target device node.  The device
1341                    information is not a duplicate of /proc/scsi/scsi because
1342                    the two may be out of sync due to scsi hotplug, rather
1343                    this info is for an app to be able to use to know how to
1344                    get them back in sync. */
1345
1346                 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
1347                         struct cciss_scsi_dev_t *sd =
1348                                 &ccissscsi[h->ctlr].dev[i];
1349                         buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1350                                 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1351                                 sh->host_no, sd->bus, sd->target, sd->lun,
1352                                 sd->devtype,
1353                                 sd->scsi3addr[0], sd->scsi3addr[1],
1354                                 sd->scsi3addr[2], sd->scsi3addr[3],
1355                                 sd->scsi3addr[4], sd->scsi3addr[5],
1356                                 sd->scsi3addr[6], sd->scsi3addr[7]);
1357                 }
1358                 datalen = buflen - offset;
1359                 if (datalen < 0) {      /* they're reading past EOF. */
1360                         datalen = 0;
1361                         *start = buffer+buflen;
1362                 } else
1363                         *start = buffer + offset;
1364                 return(datalen);
1365         } else  /* User is writing to /proc/scsi/cciss*?/?*  ... */
1366                 return cciss_scsi_user_command(h, sh->host_no,
1367                         buffer, length);
1368 }
1369
1370 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1371    dma mapping  and fills in the scatter gather entries of the
1372    cciss command, c. */
1373
1374 static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c,
1375         struct scsi_cmnd *cmd)
1376 {
1377         unsigned int len;
1378         struct scatterlist *sg;
1379         __u64 addr64;
1380         int request_nsgs, i, chained, sg_index;
1381         struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1382         SGDescriptor_struct *curr_sg;
1383
1384         BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1385
1386         chained = 0;
1387         sg_index = 0;
1388         curr_sg = c->SG;
1389         request_nsgs = scsi_dma_map(cmd);
1390         if (request_nsgs) {
1391                 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1392                         if (sg_index + 1 == h->max_cmd_sgentries &&
1393                                 !chained && request_nsgs - i > 1) {
1394                                 chained = 1;
1395                                 sg_index = 0;
1396                                 curr_sg = sa->cmd_sg_list[c->cmdindex];
1397                         }
1398                         addr64 = (__u64) sg_dma_address(sg);
1399                         len  = sg_dma_len(sg);
1400                         curr_sg[sg_index].Addr.lower =
1401                                 (__u32) (addr64 & 0x0FFFFFFFFULL);
1402                         curr_sg[sg_index].Addr.upper =
1403                                 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1404                         curr_sg[sg_index].Len = len;
1405                         curr_sg[sg_index].Ext = 0;
1406                         ++sg_index;
1407                 }
1408                 if (chained)
1409                         cciss_map_sg_chain_block(h, c,
1410                                 sa->cmd_sg_list[c->cmdindex],
1411                                 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1412                                         sizeof(SGDescriptor_struct));
1413         }
1414         /* track how many SG entries we are using */
1415         if (request_nsgs > h->maxSG)
1416                 h->maxSG = request_nsgs;
1417         c->Header.SGTotal = (__u8) request_nsgs + chained;
1418         if (request_nsgs > h->max_cmd_sgentries)
1419                 c->Header.SGList = h->max_cmd_sgentries;
1420         else
1421                 c->Header.SGList = c->Header.SGTotal;
1422         return;
1423 }
1424
1425
1426 static int
1427 cciss_scsi_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1428 {
1429         ctlr_info_t *h;
1430         int rc;
1431         unsigned char scsi3addr[8];
1432         CommandList_struct *c;
1433         unsigned long flags;
1434
1435         // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1436         // We violate cmd->host privacy here.  (Is there another way?)
1437         h = (ctlr_info_t *) cmd->device->host->hostdata[0];
1438
1439         rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id,
1440                         cmd->device->lun, scsi3addr);
1441         if (rc != 0) {
1442                 /* the scsi nexus does not match any that we presented... */
1443                 /* pretend to mid layer that we got selection timeout */
1444                 cmd->result = DID_NO_CONNECT << 16;
1445                 done(cmd);
1446                 /* we might want to think about registering controller itself
1447                    as a processor device on the bus so sg binds to it. */
1448                 return 0;
1449         }
1450
1451         /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1452            see what the device thinks of it. */
1453
1454         spin_lock_irqsave(&h->lock, flags);
1455         c = scsi_cmd_alloc(h);
1456         spin_unlock_irqrestore(&h->lock, flags);
1457         if (c == NULL) {                        /* trouble... */
1458                 dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n");
1459                 /* FIXME: next 3 lines are -> BAD! <- */
1460                 cmd->result = DID_NO_CONNECT << 16;
1461                 done(cmd);
1462                 return 0;
1463         }
1464
1465         // Fill in the command list header
1466
1467         cmd->scsi_done = done;    // save this for use by completion code
1468
1469         /* save c in case we have to abort it */
1470         cmd->host_scribble = (unsigned char *) c;
1471
1472         c->cmd_type = CMD_SCSI;
1473         c->scsi_cmd = cmd;
1474         c->Header.ReplyQueue = 0;  /* unused in simple mode */
1475         memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1476         c->Header.Tag.lower = c->busaddr;  /* Use k. address of cmd as tag */
1477
1478         // Fill in the request block...
1479
1480         c->Request.Timeout = 0;
1481         memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
1482         BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
1483         c->Request.CDBLen = cmd->cmd_len;
1484         memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
1485         c->Request.Type.Type = TYPE_CMD;
1486         c->Request.Type.Attribute = ATTR_SIMPLE;
1487         switch(cmd->sc_data_direction)
1488         {
1489           case DMA_TO_DEVICE:
1490                 c->Request.Type.Direction = XFER_WRITE;
1491                 break;
1492           case DMA_FROM_DEVICE:
1493                 c->Request.Type.Direction = XFER_READ;
1494                 break;
1495           case DMA_NONE:
1496                 c->Request.Type.Direction = XFER_NONE;
1497                 break;
1498           case DMA_BIDIRECTIONAL:
1499                 // This can happen if a buggy application does a scsi passthru
1500                 // and sets both inlen and outlen to non-zero. ( see
1501                 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1502
1503                 c->Request.Type.Direction = XFER_RSVD;
1504                 // This is technically wrong, and cciss controllers should
1505                 // reject it with CMD_INVALID, which is the most correct
1506                 // response, but non-fibre backends appear to let it
1507                 // slide by, and give the same results as if this field
1508                 // were set correctly.  Either way is acceptable for
1509                 // our purposes here.
1510
1511                 break;
1512
1513           default:
1514                 dev_warn(&h->pdev->dev, "unknown data direction: %d\n",
1515                         cmd->sc_data_direction);
1516                 BUG();
1517                 break;
1518         }
1519         cciss_scatter_gather(h, c, cmd);
1520         enqueue_cmd_and_start_io(h, c);
1521         /* the cmd'll come back via intr handler in complete_scsi_command()  */
1522         return 0;
1523 }
1524
1525 static DEF_SCSI_QCMD(cciss_scsi_queue_command)
1526
1527 static void cciss_unregister_scsi(ctlr_info_t *h)
1528 {
1529         struct cciss_scsi_adapter_data_t *sa;
1530         struct cciss_scsi_cmd_stack_t *stk;
1531         unsigned long flags;
1532
1533         /* we are being forcibly unloaded, and may not refuse. */
1534
1535         spin_lock_irqsave(&h->lock, flags);
1536         sa = h->scsi_ctlr;
1537         stk = &sa->cmd_stack;
1538
1539         /* if we weren't ever actually registered, don't unregister */
1540         if (sa->registered) {
1541                 spin_unlock_irqrestore(&h->lock, flags);
1542                 scsi_remove_host(sa->scsi_host);
1543                 scsi_host_put(sa->scsi_host);
1544                 spin_lock_irqsave(&h->lock, flags);
1545         }
1546
1547         /* set scsi_host to NULL so our detect routine will
1548            find us on register */
1549         sa->scsi_host = NULL;
1550         spin_unlock_irqrestore(&h->lock, flags);
1551         scsi_cmd_stack_free(h);
1552         kfree(sa);
1553 }
1554
1555 static int cciss_engage_scsi(ctlr_info_t *h)
1556 {
1557         struct cciss_scsi_adapter_data_t *sa;
1558         struct cciss_scsi_cmd_stack_t *stk;
1559         unsigned long flags;
1560
1561         spin_lock_irqsave(&h->lock, flags);
1562         sa = h->scsi_ctlr;
1563         stk = &sa->cmd_stack;
1564
1565         if (sa->registered) {
1566                 dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n");
1567                 spin_unlock_irqrestore(&h->lock, flags);
1568                 return -ENXIO;
1569         }
1570         sa->registered = 1;
1571         spin_unlock_irqrestore(&h->lock, flags);
1572         cciss_update_non_disk_devices(h, -1);
1573         cciss_scsi_detect(h);
1574         return 0;
1575 }
1576
1577 static void
1578 cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h)
1579 {
1580         unsigned long flags;
1581
1582         CPQ_TAPE_LOCK(h, flags);
1583         seq_printf(seq,
1584                 "Sequential access devices: %d\n\n",
1585                         ccissscsi[h->ctlr].ndevices);
1586         CPQ_TAPE_UNLOCK(h, flags);
1587 }
1588
1589 static int wait_for_device_to_become_ready(ctlr_info_t *h,
1590         unsigned char lunaddr[])
1591 {
1592         int rc;
1593         int count = 0;
1594         int waittime = HZ;
1595         CommandList_struct *c;
1596
1597         c = cmd_alloc(h);
1598         if (!c) {
1599                 dev_warn(&h->pdev->dev, "out of memory in "
1600                         "wait_for_device_to_become_ready.\n");
1601                 return IO_ERROR;
1602         }
1603
1604         /* Send test unit ready until device ready, or give up. */
1605         while (count < 20) {
1606
1607                 /* Wait for a bit.  do this first, because if we send
1608                  * the TUR right away, the reset will just abort it.
1609                  */
1610                 schedule_timeout_uninterruptible(waittime);
1611                 count++;
1612
1613                 /* Increase wait time with each try, up to a point. */
1614                 if (waittime < (HZ * 30))
1615                         waittime = waittime * 2;
1616
1617                 /* Send the Test Unit Ready */
1618                 rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0,
1619                         lunaddr, TYPE_CMD);
1620                 if (rc == 0)
1621                         rc = sendcmd_withirq_core(h, c, 0);
1622
1623                 (void) process_sendcmd_error(h, c);
1624
1625                 if (rc != 0)
1626                         goto retry_tur;
1627
1628                 if (c->err_info->CommandStatus == CMD_SUCCESS)
1629                         break;
1630
1631                 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1632                         c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1633                         if (c->err_info->SenseInfo[2] == NO_SENSE)
1634                                 break;
1635                         if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1636                                 unsigned char asc;
1637                                 asc = c->err_info->SenseInfo[12];
1638                                 check_for_unit_attention(h, c);
1639                                 if (asc == POWER_OR_RESET)
1640                                         break;
1641                         }
1642                 }
1643 retry_tur:
1644                 dev_warn(&h->pdev->dev, "Waiting %d secs "
1645                         "for device to become ready.\n",
1646                         waittime / HZ);
1647                 rc = 1; /* device not ready. */
1648         }
1649
1650         if (rc)
1651                 dev_warn(&h->pdev->dev, "giving up on device.\n");
1652         else
1653                 dev_warn(&h->pdev->dev, "device is ready.\n");
1654
1655         cmd_free(h, c);
1656         return rc;
1657 }
1658
1659 /* Need at least one of these error handlers to keep ../scsi/hosts.c from
1660  * complaining.  Doing a host- or bus-reset can't do anything good here.
1661  * Despite what it might say in scsi_error.c, there may well be commands
1662  * on the controller, as the cciss driver registers twice, once as a block
1663  * device for the logical drives, and once as a scsi device, for any tape
1664  * drives.  So we know there are no commands out on the tape drives, but we
1665  * don't know there are no commands on the controller, and it is likely
1666  * that there probably are, as the cciss block device is most commonly used
1667  * as a boot device (embedded controller on HP/Compaq systems.)
1668 */
1669
1670 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1671 {
1672         int rc;
1673         CommandList_struct *cmd_in_trouble;
1674         unsigned char lunaddr[8];
1675         ctlr_info_t *h;
1676
1677         /* find the controller to which the command to be aborted was sent */
1678         h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1679         if (h == NULL) /* paranoia */
1680                 return FAILED;
1681         dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n");
1682         /* find the command that's giving us trouble */
1683         cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1684         if (cmd_in_trouble == NULL) /* paranoia */
1685                 return FAILED;
1686         memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1687         /* send a reset to the SCSI LUN which the command was sent to */
1688         rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr,
1689                 TYPE_MSG);
1690         if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0)
1691                 return SUCCESS;
1692         dev_warn(&h->pdev->dev, "resetting device failed.\n");
1693         return FAILED;
1694 }
1695
1696 static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1697 {
1698         int rc;
1699         CommandList_struct *cmd_to_abort;
1700         unsigned char lunaddr[8];
1701         ctlr_info_t *h;
1702
1703         /* find the controller to which the command to be aborted was sent */
1704         h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1705         if (h == NULL) /* paranoia */
1706                 return FAILED;
1707         dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n");
1708
1709         /* find the command to be aborted */
1710         cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1711         if (cmd_to_abort == NULL) /* paranoia */
1712                 return FAILED;
1713         memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1714         rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag,
1715                 0, 0, lunaddr, TYPE_MSG);
1716         if (rc == 0)
1717                 return SUCCESS;
1718         return FAILED;
1719
1720 }
1721
1722 #else /* no CONFIG_CISS_SCSI_TAPE */
1723
1724 /* If no tape support, then these become defined out of existence */
1725
1726 #define cciss_scsi_setup(cntl_num)
1727
1728 #endif /* CONFIG_CISS_SCSI_TAPE */