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