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