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