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         /* printk(KERN_WARNING "cciss_scsi.c: 0x%08x 0x%08x 0x%08x\n",
 217                         0xdeadbeef, sizeof(*stk->pool), 0xbeefdead); */
 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(hba[ctlr]->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(int ctlr)
 240 {
 241         struct cciss_scsi_adapter_data_t *sa;
 242         struct cciss_scsi_cmd_stack_t *stk;
 243         size_t size;
 244
 245         sa = hba[ctlr]->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(hba[ctlr]->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(int ctlr, int *bus, int *target, int *lun)
 348 {
 349         /* finds an unused bus, target, lun for a new device */
 350         /* assumes hba[ctlr]->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[ctlr].ndevices;i++)
 358                 target_taken[ccissscsi[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(int ctlr, int hostno,
 375                 struct cciss_scsi_dev_t *device,
 376                 struct scsi2map *added, int *nadded)
 377 {
 378         /* assumes hba[ctlr]->scsi_ctlr->lock is held */
 379         int n = ccissscsi[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", 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[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[ctlr].dev[n];
 416         if (lun == 0) {
 417                 if (find_bus_target_lun(ctlr,
 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[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                         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(int ctlr, int hostno, int entry,
 450         struct scsi2map *removed, int *nremoved)
 451 {
 452         /* assumes hba[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[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[ctlr].ndevices-1;i++)
 463                 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
 464         ccissscsi[ctlr].ndevices--;
 465         printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
 466                 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(int ctlr, 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(ctlr, flags);
 488         for (i = 0; i < ccissscsi[ctlr].ndevices; i++) {
 489                 if (memcmp(scsi3addr,
 490                                 ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) {
 491                         for (j = i; j < ccissscsi[ctlr].ndevices-1; j++)
 492                                 ccissscsi[ctlr].dev[j] =
 493                                         ccissscsi[ctlr].dev[j+1];
 494                         ccissscsi[ctlr].ndevices--;
 495                         break;
 496                 }
 497         }
 498         CPQ_TAPE_UNLOCK(ctlr, 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(int ctlr, 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", ctlr);
 541                 goto free_and_out;
 542         }
 543
 544         CPQ_TAPE_LOCK(ctlr, flags);
 545
 546         if (hostno != -1)  /* if it's not the first time... */
 547                 sh = hba[ctlr]->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[ctlr].ndevices) {
 556                 csd = &ccissscsi[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                                 ctlr, scsi_device_type(csd->devtype), hostno,
 573                                         csd->bus, csd->target, csd->lun); */
 574                         cciss_scsi_remove_entry(ctlr, 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                                 ctlr, hostno, csd->bus, csd->target, csd->lun);
 581                         cciss_scsi_remove_entry(ctlr, hostno, i,
 582                                 removed, &nremoved);
 583                         /* remove ^^^, hence i not incremented */
 584                         if (cciss_scsi_add_entry(ctlr, hostno, &sd[j],
 585                                 added, &nadded) != 0)
 586                                 /* we just removed one, so add can't fail. */
 587                                         BUG();
 588                         csd->devtype = sd[j].devtype;
 589                         memcpy(csd->device_id, sd[j].device_id,
 590                                 sizeof(csd->device_id));
 591                         memcpy(csd->vendor, sd[j].vendor,
 592                                 sizeof(csd->vendor));
 593                         memcpy(csd->model, sd[j].model,
 594                                 sizeof(csd->model));
 595                         memcpy(csd->revision, sd[j].revision,
 596                                 sizeof(csd->revision));
 597                 } else          /* device is same as it ever was, */
 598                         i++;    /* so just move along. */
 599         }
 600
 601         /* Now, make sure every device listed in sd[] is also
 602            listed in ccissscsi[], adding them if they aren't found */
 603
 604         for (i=0;i<nsds;i++) {
 605                 found=0;
 606                 for (j=0;j<ccissscsi[ctlr].ndevices;j++) {
 607                         csd = &ccissscsi[ctlr].dev[j];
 608                         if (SCSI3ADDR_EQ(sd[i].scsi3addr,
 609                                 csd->scsi3addr)) {
 610                                 if (device_is_the_same(&sd[i], csd))
 611                                         found=2;        /* found device */
 612                                 else
 613                                         found=1;        /* found a bug. */
 614                                 break;
 615                         }
 616                 }
 617                 if (!found) {
 618                         changes++;
 619                         if (cciss_scsi_add_entry(ctlr, hostno, &sd[i],
 620                                 added, &nadded) != 0)
 621                                 break;
 622                 } else if (found == 1) {
 623                         /* should never happen... */
 624                         changes++;
 625                         printk(KERN_WARNING "cciss%d: device "
 626                                 "unexpectedly changed\n", ctlr);
 627                         /* but if it does happen, we just ignore that device */
 628                 }
 629         }
 630         CPQ_TAPE_UNLOCK(ctlr, flags);
 631
 632         /* Don't notify scsi mid layer of any changes the first time through */
 633         /* (or if there are no changes) scsi_scan_host will do it later the */
 634         /* first time through. */
 635         if (hostno == -1 || !changes)
 636                 goto free_and_out;
 637
 638         /* Notify scsi mid layer of any removed devices */
 639         for (i = 0; i < nremoved; i++) {
 640                 struct scsi_device *sdev =
 641                         scsi_device_lookup(sh, removed[i].bus,
 642                                 removed[i].target, removed[i].lun);
 643                 if (sdev != NULL) {
 644                         scsi_remove_device(sdev);
 645                         scsi_device_put(sdev);
 646                 } else {
 647                         /* We don't expect to get here. */
 648                         /* future cmds to this device will get selection */
 649                         /* timeout as if the device was gone. */
 650                         printk(KERN_WARNING "cciss%d: didn't find "
 651                                 "c%db%dt%dl%d\n for removal.",
 652                                 ctlr, hostno, removed[i].bus,
 653                                 removed[i].target, removed[i].lun);
 654                 }
 655         }
 656
 657         /* Notify scsi mid layer of any added devices */
 658         for (i = 0; i < nadded; i++) {
 659                 int rc;
 660                 rc = scsi_add_device(sh, added[i].bus,
 661                         added[i].target, added[i].lun);
 662                 if (rc == 0)
 663                         continue;
 664                 printk(KERN_WARNING "cciss%d: scsi_add_device "
 665                         "c%db%dt%dl%d failed, device not added.\n",
 666                         ctlr, hostno,
 667                         added[i].bus, added[i].target, added[i].lun);
 668                 /* now we have to remove it from ccissscsi, */
 669                 /* since it didn't get added to scsi mid layer */
 670                 fixup_botched_add(ctlr, added[i].scsi3addr);
 671         }
 672
 673 free_and_out:
 674         kfree(added);
 675         kfree(removed);
 676         return 0;
 677 }
 678
 679 static int
 680 lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)
 681 {
 682         int i;
 683         struct cciss_scsi_dev_t *sd;
 684         unsigned long flags;
 685
 686         CPQ_TAPE_LOCK(ctlr, flags);
 687         for (i=0;i<ccissscsi[ctlr].ndevices;i++) {
 688                 sd = &ccissscsi[ctlr].dev[i];
 689                 if (sd->bus == bus &&
 690                     sd->target == target &&
 691                     sd->lun == lun) {
 692                         memcpy(scsi3addr, &sd->scsi3addr[0], 8);
 693                         CPQ_TAPE_UNLOCK(ctlr, flags);
 694                         return 0;
 695                 }
 696         }
 697         CPQ_TAPE_UNLOCK(ctlr, flags);
 698         return -1;
 699 }
 700
 701 static void
 702 cciss_scsi_setup(int cntl_num)
 703 {
 704         struct cciss_scsi_adapter_data_t * shba;
 705
 706         ccissscsi[cntl_num].ndevices = 0;
 707         shba = (struct cciss_scsi_adapter_data_t *)
 708                 kmalloc(sizeof(*shba), GFP_KERNEL);
 709         if (shba == NULL)
 710                 return;
 711         shba->scsi_host = NULL;
 712         spin_lock_init(&shba->lock);
 713         shba->registered = 0;
 714         if (scsi_cmd_stack_setup(cntl_num, shba) != 0) {
 715                 kfree(shba);
 716                 shba = NULL;
 717         }
 718         hba[cntl_num]->scsi_ctlr = shba;
 719         return;
 720 }
 721
 722 static void
 723 complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
 724 {
 725         struct scsi_cmnd *cmd;
 726         ctlr_info_t *ctlr;
 727         ErrorInfo_struct *ei;
 728
 729         ei = cp->err_info;
 730
 731         /* First, see if it was a message rather than a command */
 732         if (cp->Request.Type.Type == TYPE_MSG)  {
 733                 cp->cmd_type = CMD_MSG_DONE;
 734                 return;
 735         }
 736
 737         cmd = (struct scsi_cmnd *) cp->scsi_cmd;
 738         ctlr = hba[cp->ctlr];
 739
 740         scsi_dma_unmap(cmd);
 741         if (cp->Header.SGTotal > ctlr->max_cmd_sgentries)
 742                 cciss_unmap_sg_chain_block(ctlr, cp);
 743
 744         cmd->result = (DID_OK << 16);           /* host byte */
 745         cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
 746         /* cmd->result |= (GOOD < 1); */                /* status byte */
 747
 748         cmd->result |= (ei->ScsiStatus);
 749         /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus);  */
 750
 751         /* copy the sense data whether we need to or not. */
 752
 753         memcpy(cmd->sense_buffer, ei->SenseInfo,
 754                 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
 755                         SCSI_SENSE_BUFFERSIZE :
 756                         ei->SenseLen);
 757         scsi_set_resid(cmd, ei->ResidualCnt);
 758
 759         if(ei->CommandStatus != 0)
 760         { /* an error has occurred */
 761                 switch(ei->CommandStatus)
 762                 {
 763                         case CMD_TARGET_STATUS:
 764                                 /* Pass it up to the upper layers... */
 765                                 if( ei->ScsiStatus)
 766                                 {
 767 #if 0
 768                                         printk(KERN_WARNING "cciss: cmd %p "
 769                                         "has SCSI Status = %x\n",
 770                                                 cp,
 771                                                 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: cp %p has"
 792                                         " completed with data overrun "
 793                                         "reported\n", cp);
 794                         break;
 795                         case CMD_INVALID: {
 796                                 /* print_bytes(cp, sizeof(*cp), 1, 0);
 797                                 print_cmd(cp); */
 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: cp %p has "
 808                                         "protocol error \n", cp);
 809                         break;
 810                         case CMD_HARDWARE_ERR:
 811                                 cmd->result = DID_ERROR << 16;
 812                                 printk(KERN_WARNING "cciss: cp %p had "
 813                                         " hardware error\n", cp);
 814                         break;
 815                         case CMD_CONNECTION_LOST:
 816                                 cmd->result = DID_ERROR << 16;
 817                                 printk(KERN_WARNING "cciss: cp %p had "
 818                                         "connection lost\n", cp);
 819                         break;
 820                         case CMD_ABORTED:
 821                                 cmd->result = DID_ABORT << 16;
 822                                 printk(KERN_WARNING "cciss: cp %p was "
 823                                         "aborted\n", cp);
 824                         break;
 825                         case CMD_ABORT_FAILED:
 826                                 cmd->result = DID_ERROR << 16;
 827                                 printk(KERN_WARNING "cciss: cp %p reports "
 828                                         "abort failed\n", cp);
 829                         break;
 830                         case CMD_UNSOLICITED_ABORT:
 831                                 cmd->result = DID_ABORT << 16;
 832                                 printk(KERN_WARNING "cciss: cp %p aborted "
 833                                         "do to an unsolicited abort\n", cp);
 834                         break;
 835                         case CMD_TIMEOUT:
 836                                 cmd->result = DID_TIME_OUT << 16;
 837                                 printk(KERN_WARNING "cciss: cp %p timedout\n",
 838                                         cp);
 839                         break;
 840                         default:
 841                                 cmd->result = DID_ERROR << 16;
 842                                 printk(KERN_WARNING "cciss: cp %p returned "
 843                                         "unknown status %x\n", cp,
 844                                                 ei->CommandStatus);
 845                 }
 846         }
 847         // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel,
 848         //      cmd->target, cmd->lun);
 849         cmd->scsi_done(cmd);
 850         scsi_cmd_free(ctlr, cp);
 851 }
 852
 853 static int
 854 cciss_scsi_detect(int ctlr)
 855 {
 856         struct Scsi_Host *sh;
 857         int error;
 858
 859         sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
 860         if (sh == NULL)
 861                 goto fail;
 862         sh->io_port = 0;        // good enough?  FIXME,
 863         sh->n_io_port = 0;      // I don't think we use these two...
 864         sh->this_id = SELF_SCSI_ID;
 865         sh->sg_tablesize = hba[ctlr]->maxsgentries;
 866         sh->max_cmd_len = MAX_COMMAND_SIZE;
 867
 868         ((struct cciss_scsi_adapter_data_t *)
 869                 hba[ctlr]->scsi_ctlr)->scsi_host = sh;
 870         sh->hostdata[0] = (unsigned long) hba[ctlr];
 871         sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT];
 872         sh->unique_id = sh->irq;
 873         error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
 874         if (error)
 875                 goto fail_host_put;
 876         scsi_scan_host(sh);
 877         return 1;
 878
 879  fail_host_put:
 880         scsi_host_put(sh);
 881  fail:
 882         return 0;
 883 }
 884
 885 static void
 886 cciss_unmap_one(struct pci_dev *pdev,
 887                 CommandList_struct *cp,
 888                 size_t buflen,
 889                 int data_direction)
 890 {
 891         u64bit addr64;
 892
 893         addr64.val32.lower = cp->SG[0].Addr.lower;
 894         addr64.val32.upper = cp->SG[0].Addr.upper;
 895         pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
 896 }
 897
 898 static void
 899 cciss_map_one(struct pci_dev *pdev,
 900                 CommandList_struct *cp,
 901                 unsigned char *buf,
 902                 size_t buflen,
 903                 int data_direction)
 904 {
 905         __u64 addr64;
 906
 907         addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
 908         cp->SG[0].Addr.lower =
 909           (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
 910         cp->SG[0].Addr.upper =
 911           (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
 912         cp->SG[0].Len = buflen;
 913         cp->Header.SGList = (__u8) 1;   /* no. SGs contig in this cmd */
 914         cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
 915 }
 916
 917 static int
 918 cciss_scsi_do_simple_cmd(ctlr_info_t *c,
 919                         CommandList_struct *cp,
 920                         unsigned char *scsi3addr,
 921                         unsigned char *cdb,
 922                         unsigned char cdblen,
 923                         unsigned char *buf, int bufsize,
 924                         int direction)
 925 {
 926         unsigned long flags;
 927         DECLARE_COMPLETION_ONSTACK(wait);
 928
 929         cp->cmd_type = CMD_IOCTL_PEND;          // treat this like an ioctl
 930         cp->scsi_cmd = NULL;
 931         cp->Header.ReplyQueue = 0;  // unused in simple mode
 932         memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
 933         cp->Header.Tag.lower = cp->busaddr;  // Use k. address of cmd as tag
 934         // Fill in the request block...
 935
 936         /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
 937                 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
 938                 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
 939
 940         memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
 941         memcpy(cp->Request.CDB, cdb, cdblen);
 942         cp->Request.Timeout = 0;
 943         cp->Request.CDBLen = cdblen;
 944         cp->Request.Type.Type = TYPE_CMD;
 945         cp->Request.Type.Attribute = ATTR_SIMPLE;
 946         cp->Request.Type.Direction = direction;
 947
 948         /* Fill in the SG list and do dma mapping */
 949         cciss_map_one(c->pdev, cp, (unsigned char *) buf,
 950                         bufsize, DMA_FROM_DEVICE);
 951
 952         cp->waiting = &wait;
 953
 954         /* Put the request on the tail of the request queue */
 955         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
 956         addQ(&c->reqQ, cp);
 957         c->Qdepth++;
 958         start_io(c);
 959         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
 960
 961         wait_for_completion(&wait);
 962
 963         /* undo the dma mapping */
 964         cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
 965         return(0);
 966 }
 967
 968 static void
 969 cciss_scsi_interpret_error(CommandList_struct *cp)
 970 {
 971         ErrorInfo_struct *ei;
 972
 973         ei = cp->err_info;
 974         switch(ei->CommandStatus)
 975         {
 976                 case CMD_TARGET_STATUS:
 977                         printk(KERN_WARNING "cciss: cmd %p has "
 978                                 "completed with errors\n", cp);
 979                         printk(KERN_WARNING "cciss: cmd %p "
 980                                 "has SCSI Status = %x\n",
 981                                         cp,
 982                                         ei->ScsiStatus);
 983                         if (ei->ScsiStatus == 0)
 984                                 printk(KERN_WARNING
 985                                 "cciss:SCSI status is abnormally zero.  "
 986                                 "(probably indicates selection timeout "
 987                                 "reported incorrectly due to a known "
 988                                 "firmware bug, circa July, 2001.)\n");
 989                 break;
 990                 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
 991                         printk("UNDERRUN\n");
 992                 break;
 993                 case CMD_DATA_OVERRUN:
 994                         printk(KERN_WARNING "cciss: cp %p has"
 995                                 " completed with data overrun "
 996                                 "reported\n", cp);
 997                 break;
 998                 case CMD_INVALID: {
 999                         /* controller unfortunately reports SCSI passthru's */
1000                         /* to non-existent targets as invalid commands. */
1001                         printk(KERN_WARNING "cciss: cp %p is "
1002                                 "reported invalid (probably means "
1003                                 "target device no longer present)\n",
1004                                 cp);
1005                         /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
1006                         print_cmd(cp);  */
1007                         }
1008                 break;
1009                 case CMD_PROTOCOL_ERR:
1010                         printk(KERN_WARNING "cciss: cp %p has "
1011                                 "protocol error \n", cp);
1012                 break;
1013                 case CMD_HARDWARE_ERR:
1014                         /* cmd->result = DID_ERROR << 16; */
1015                         printk(KERN_WARNING "cciss: cp %p had "
1016                                 " hardware error\n", cp);
1017                 break;
1018                 case CMD_CONNECTION_LOST:
1019                         printk(KERN_WARNING "cciss: cp %p had "
1020                                 "connection lost\n", cp);
1021                 break;
1022                 case CMD_ABORTED:
1023                         printk(KERN_WARNING "cciss: cp %p was "
1024                                 "aborted\n", cp);
1025                 break;
1026                 case CMD_ABORT_FAILED:
1027                         printk(KERN_WARNING "cciss: cp %p reports "
1028                                 "abort failed\n", cp);
1029                 break;
1030                 case CMD_UNSOLICITED_ABORT:
1031                         printk(KERN_WARNING "cciss: cp %p aborted "
1032                                 "do to an unsolicited abort\n", cp);
1033                 break;
1034                 case CMD_TIMEOUT:
1035                         printk(KERN_WARNING "cciss: cp %p timedout\n",
1036                                 cp);
1037                 break;
1038                 default:
1039                         printk(KERN_WARNING "cciss: cp %p returned "
1040                                 "unknown status %x\n", cp,
1041                                         ei->CommandStatus);
1042         }
1043 }
1044
1045 static int
1046 cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr,
1047         unsigned char page, unsigned char *buf,
1048         unsigned char bufsize)
1049 {
1050         int rc;
1051         CommandList_struct *cp;
1052         char cdb[6];
1053         ErrorInfo_struct *ei;
1054         unsigned long flags;
1055
1056         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1057         cp = scsi_cmd_alloc(c);
1058         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1059
1060         if (cp == NULL) {                       /* trouble... */
1061                 printk("cmd_alloc returned NULL!\n");
1062                 return -1;
1063         }
1064
1065         ei = cp->err_info;
1066
1067         cdb[0] = CISS_INQUIRY;
1068         cdb[1] = (page != 0);
1069         cdb[2] = page;
1070         cdb[3] = 0;
1071         cdb[4] = bufsize;
1072         cdb[5] = 0;
1073         rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb,
1074                                 6, buf, bufsize, XFER_READ);
1075
1076         if (rc != 0) return rc; /* something went wrong */
1077
1078         if (ei->CommandStatus != 0 &&
1079             ei->CommandStatus != CMD_DATA_UNDERRUN) {
1080                 cciss_scsi_interpret_error(cp);
1081                 rc = -1;
1082         }
1083         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1084         scsi_cmd_free(c, cp);
1085         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1086         return rc;
1087 }
1088
1089 /* Get the device id from inquiry page 0x83 */
1090 static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1091         unsigned char *device_id, int buflen)
1092 {
1093         int rc;
1094         unsigned char *buf;
1095
1096         if (buflen > 16)
1097                 buflen = 16;
1098         buf = kzalloc(64, GFP_KERNEL);
1099         if (!buf)
1100                 return -1;
1101         rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64);
1102         if (rc == 0)
1103                 memcpy(device_id, &buf[8], buflen);
1104         kfree(buf);
1105         return rc != 0;
1106 }
1107
1108 static int
1109 cciss_scsi_do_report_phys_luns(ctlr_info_t *c,
1110                 ReportLunData_struct *buf, int bufsize)
1111 {
1112         int rc;
1113         CommandList_struct *cp;
1114         unsigned char cdb[12];
1115         unsigned char scsi3addr[8];
1116         ErrorInfo_struct *ei;
1117         unsigned long flags;
1118
1119         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1120         cp = scsi_cmd_alloc(c);
1121         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1122         if (cp == NULL) {                       /* trouble... */
1123                 printk("cmd_alloc returned NULL!\n");
1124                 return -1;
1125         }
1126
1127         memset(&scsi3addr[0], 0, 8); /* address the controller */
1128         cdb[0] = CISS_REPORT_PHYS;
1129         cdb[1] = 0;
1130         cdb[2] = 0;
1131         cdb[3] = 0;
1132         cdb[4] = 0;
1133         cdb[5] = 0;
1134         cdb[6] = (bufsize >> 24) & 0xFF;  //MSB
1135         cdb[7] = (bufsize >> 16) & 0xFF;
1136         cdb[8] = (bufsize >> 8) & 0xFF;
1137         cdb[9] = bufsize & 0xFF;
1138         cdb[10] = 0;
1139         cdb[11] = 0;
1140
1141         rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr,
1142                                 cdb, 12,
1143                                 (unsigned char *) buf,
1144                                 bufsize, XFER_READ);
1145
1146         if (rc != 0) return rc; /* something went wrong */
1147
1148         ei = cp->err_info;
1149         if (ei->CommandStatus != 0 &&
1150             ei->CommandStatus != CMD_DATA_UNDERRUN) {
1151                 cciss_scsi_interpret_error(cp);
1152                 rc = -1;
1153         }
1154         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1155         scsi_cmd_free(c, cp);
1156         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1157         return rc;
1158 }
1159
1160 static void
1161 cciss_update_non_disk_devices(int cntl_num, int hostno)
1162 {
1163         /* the idea here is we could get notified from /proc
1164            that some devices have changed, so we do a report
1165            physical luns cmd, and adjust our list of devices
1166            accordingly.  (We can't rely on the scsi-mid layer just
1167            doing inquiries, because the "busses" that the scsi
1168            mid-layer probes are totally fabricated by this driver,
1169            so new devices wouldn't show up.
1170
1171            the scsi3addr's of devices won't change so long as the
1172            adapter is not reset.  That means we can rescan and
1173            tell which devices we already know about, vs. new
1174            devices, vs.  disappearing devices.
1175
1176            Also, if you yank out a tape drive, then put in a disk
1177            in it's place, (say, a configured volume from another
1178            array controller for instance)  _don't_ poke this driver
1179            (so it thinks it's still a tape, but _do_ poke the scsi
1180            mid layer, so it does an inquiry... the scsi mid layer
1181            will see the physical disk.  This would be bad.  Need to
1182            think about how to prevent that.  One idea would be to
1183            snoop all scsi responses and if an inquiry repsonse comes
1184            back that reports a disk, chuck it an return selection
1185            timeout instead and adjust our table...  Not sure i like
1186            that though.
1187
1188          */
1189 #define OBDR_TAPE_INQ_SIZE 49
1190 #define OBDR_TAPE_SIG "$DR-10"
1191         ReportLunData_struct *ld_buff;
1192         unsigned char *inq_buff;
1193         unsigned char scsi3addr[8];
1194         ctlr_info_t *c;
1195         __u32 num_luns=0;
1196         unsigned char *ch;
1197         struct cciss_scsi_dev_t *currentsd, *this_device;
1198         int ncurrent=0;
1199         int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1200         int i;
1201
1202         c = (ctlr_info_t *) hba[cntl_num];
1203         ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1204         inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1205         currentsd = kzalloc(sizeof(*currentsd) *
1206                         (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1207         if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1208                 printk(KERN_ERR "cciss: out of memory\n");
1209                 goto out;
1210         }
1211         this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1212         if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1213                 ch = &ld_buff->LUNListLength[0];
1214                 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1215                 if (num_luns > CISS_MAX_PHYS_LUN) {
1216                         printk(KERN_WARNING
1217                                 "cciss: Maximum physical LUNs (%d) exceeded.  "
1218                                 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1219                                 num_luns - CISS_MAX_PHYS_LUN);
1220                         num_luns = CISS_MAX_PHYS_LUN;
1221                 }
1222         }
1223         else {
1224                 printk(KERN_ERR  "cciss: Report physical LUNs failed.\n");
1225                 goto out;
1226         }
1227
1228
1229         /* adjust our table of devices */
1230         for (i = 0; i < num_luns; i++) {
1231                 /* for each physical lun, do an inquiry */
1232                 if (ld_buff->LUN[i][3] & 0xC0) continue;
1233                 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1234                 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1235
1236                 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff,
1237                         (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1238                         /* Inquiry failed (msg printed already) */
1239                         continue; /* so we will skip this device. */
1240
1241                 this_device->devtype = (inq_buff[0] & 0x1f);
1242                 this_device->bus = -1;
1243                 this_device->target = -1;
1244                 this_device->lun = -1;
1245                 memcpy(this_device->scsi3addr, scsi3addr, 8);
1246                 memcpy(this_device->vendor, &inq_buff[8],
1247                         sizeof(this_device->vendor));
1248                 memcpy(this_device->model, &inq_buff[16],
1249                         sizeof(this_device->model));
1250                 memcpy(this_device->revision, &inq_buff[32],
1251                         sizeof(this_device->revision));
1252                 memset(this_device->device_id, 0,
1253                         sizeof(this_device->device_id));
1254                 cciss_scsi_get_device_id(hba[cntl_num], scsi3addr,
1255                         this_device->device_id, sizeof(this_device->device_id));
1256
1257                 switch (this_device->devtype)
1258                 {
1259                   case 0x05: /* CD-ROM */ {
1260
1261                         /* We don't *really* support actual CD-ROM devices,
1262                          * just this "One Button Disaster Recovery" tape drive
1263                          * which temporarily pretends to be a CD-ROM drive.
1264                          * So we check that the device is really an OBDR tape
1265                          * device by checking for "$DR-10" in bytes 43-48 of
1266                          * the inquiry data.
1267                          */
1268                                 char obdr_sig[7];
1269
1270                                 strncpy(obdr_sig, &inq_buff[43], 6);
1271                                 obdr_sig[6] = '\0';
1272                                 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1273                                         /* Not OBDR device, ignore it. */
1274                                         break;
1275                         }
1276                         /* fall through . . . */
1277                   case 0x01: /* sequential access, (tape) */
1278                   case 0x08: /* medium changer */
1279                         if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1280                                 printk(KERN_INFO "cciss%d: %s ignored, "
1281                                         "too many devices.\n", cntl_num,
1282                                         scsi_device_type(this_device->devtype));
1283                                 break;
1284                         }
1285                         currentsd[ncurrent] = *this_device;
1286                         ncurrent++;
1287                         break;
1288                   default:
1289                         break;
1290                 }
1291         }
1292
1293         adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1294 out:
1295         kfree(inq_buff);
1296         kfree(ld_buff);
1297         kfree(currentsd);
1298         return;
1299 }
1300
1301 static int
1302 is_keyword(char *ptr, int len, char *verb)  // Thanks to ncr53c8xx.c
1303 {
1304         int verb_len = strlen(verb);
1305         if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1306                 return verb_len;
1307         else
1308                 return 0;
1309 }
1310
1311 static int
1312 cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1313 {
1314         int arg_len;
1315
1316         if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1317                 cciss_update_non_disk_devices(ctlr, hostno);
1318         else
1319                 return -EINVAL;
1320         return length;
1321 }
1322
1323
1324 static int
1325 cciss_scsi_proc_info(struct Scsi_Host *sh,
1326                 char *buffer, /* data buffer */
1327                 char **start,      /* where data in buffer starts */
1328                 off_t offset,      /* offset from start of imaginary file */
1329                 int length,        /* length of data in buffer */
1330                 int func)          /* 0 == read, 1 == write */
1331 {
1332
1333         int buflen, datalen;
1334         ctlr_info_t *ci;
1335         int i;
1336         int cntl_num;
1337
1338
1339         ci = (ctlr_info_t *) sh->hostdata[0];
1340         if (ci == NULL)  /* This really shouldn't ever happen. */
1341                 return -EINVAL;
1342
1343         cntl_num = ci->ctlr;    /* Get our index into the hba[] array */
1344
1345         if (func == 0) {        /* User is reading from /proc/scsi/ciss*?/?*  */
1346                 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1347                                 cntl_num, sh->host_no);
1348
1349                 /* this information is needed by apps to know which cciss
1350                    device corresponds to which scsi host number without
1351                    having to open a scsi target device node.  The device
1352                    information is not a duplicate of /proc/scsi/scsi because
1353                    the two may be out of sync due to scsi hotplug, rather
1354                    this info is for an app to be able to use to know how to
1355                    get them back in sync. */
1356
1357                 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) {
1358                         struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i];
1359                         buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1360                                 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1361                                 sh->host_no, sd->bus, sd->target, sd->lun,
1362                                 sd->devtype,
1363                                 sd->scsi3addr[0], sd->scsi3addr[1],
1364                                 sd->scsi3addr[2], sd->scsi3addr[3],
1365                                 sd->scsi3addr[4], sd->scsi3addr[5],
1366                                 sd->scsi3addr[6], sd->scsi3addr[7]);
1367                 }
1368                 datalen = buflen - offset;
1369                 if (datalen < 0) {      /* they're reading past EOF. */
1370                         datalen = 0;
1371                         *start = buffer+buflen;
1372                 } else
1373                         *start = buffer + offset;
1374                 return(datalen);
1375         } else  /* User is writing to /proc/scsi/cciss*?/?*  ... */
1376                 return cciss_scsi_user_command(cntl_num, sh->host_no,
1377                         buffer, length);
1378 }
1379
1380 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1381    dma mapping  and fills in the scatter gather entries of the
1382    cciss command, cp. */
1383
1384 static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1385         struct scsi_cmnd *cmd)
1386 {
1387         unsigned int len;
1388         struct scatterlist *sg;
1389         __u64 addr64;
1390         int request_nsgs, i, chained, sg_index;
1391         struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1392         SGDescriptor_struct *curr_sg;
1393
1394         BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1395
1396         chained = 0;
1397         sg_index = 0;
1398         curr_sg = cp->SG;
1399         request_nsgs = scsi_dma_map(cmd);
1400         if (request_nsgs) {
1401                 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1402                         if (sg_index + 1 == h->max_cmd_sgentries &&
1403                                 !chained && request_nsgs - i > 1) {
1404                                 chained = 1;
1405                                 sg_index = 0;
1406                                 curr_sg = sa->cmd_sg_list[cp->cmdindex];
1407                         }
1408                         addr64 = (__u64) sg_dma_address(sg);
1409                         len  = sg_dma_len(sg);
1410                         curr_sg[sg_index].Addr.lower =
1411                                 (__u32) (addr64 & 0x0FFFFFFFFULL);
1412                         curr_sg[sg_index].Addr.upper =
1413                                 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1414                         curr_sg[sg_index].Len = len;
1415                         curr_sg[sg_index].Ext = 0;
1416                         ++sg_index;
1417                 }
1418                 if (chained)
1419                         cciss_map_sg_chain_block(h, cp,
1420                                 sa->cmd_sg_list[cp->cmdindex],
1421                                 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1422                                         sizeof(SGDescriptor_struct));
1423         }
1424         /* track how many SG entries we are using */
1425         if (request_nsgs > h->maxSG)
1426                 h->maxSG = request_nsgs;
1427         cp->Header.SGTotal = (__u8) request_nsgs + chained;
1428         if (request_nsgs > h->max_cmd_sgentries)
1429                 cp->Header.SGList = h->max_cmd_sgentries;
1430         else
1431                 cp->Header.SGList = cp->Header.SGTotal;
1432         return;
1433 }
1434
1435
1436 static int
1437 cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1438 {
1439         ctlr_info_t *c;
1440         int ctlr, rc;
1441         unsigned char scsi3addr[8];
1442         CommandList_struct *cp;
1443         unsigned long flags;
1444
1445         // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1446         // We violate cmd->host privacy here.  (Is there another way?)
1447         c = (ctlr_info_t *) cmd->device->host->hostdata[0];
1448         ctlr = c->ctlr;
1449
1450         rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id,
1451                         cmd->device->lun, scsi3addr);
1452         if (rc != 0) {
1453                 /* the scsi nexus does not match any that we presented... */
1454                 /* pretend to mid layer that we got selection timeout */
1455                 cmd->result = DID_NO_CONNECT << 16;
1456                 done(cmd);
1457                 /* we might want to think about registering controller itself
1458                    as a processor device on the bus so sg binds to it. */
1459                 return 0;
1460         }
1461
1462         /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n",
1463                 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1464         // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel,
1465         //      cmd->target, cmd->lun);
1466
1467         /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1468            see what the device thinks of it. */
1469
1470         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1471         cp = scsi_cmd_alloc(c);
1472         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1473         if (cp == NULL) {                       /* trouble... */
1474                 printk("scsi_cmd_alloc returned NULL!\n");
1475                 /* FIXME: next 3 lines are -> BAD! <- */
1476                 cmd->result = DID_NO_CONNECT << 16;
1477                 done(cmd);
1478                 return 0;
1479         }
1480
1481         // Fill in the command list header
1482
1483         cmd->scsi_done = done;    // save this for use by completion code
1484
1485         // save cp in case we have to abort it
1486         cmd->host_scribble = (unsigned char *) cp;
1487
1488         cp->cmd_type = CMD_SCSI;
1489         cp->scsi_cmd = cmd;
1490         cp->Header.ReplyQueue = 0;  // unused in simple mode
1491         memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1492         cp->Header.Tag.lower = cp->busaddr;  // Use k. address of cmd as tag
1493
1494         // Fill in the request block...
1495
1496         cp->Request.Timeout = 0;
1497         memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
1498         BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB));
1499         cp->Request.CDBLen = cmd->cmd_len;
1500         memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1501         cp->Request.Type.Type = TYPE_CMD;
1502         cp->Request.Type.Attribute = ATTR_SIMPLE;
1503         switch(cmd->sc_data_direction)
1504         {
1505           case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1506           case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1507           case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1508           case DMA_BIDIRECTIONAL:
1509                 // This can happen if a buggy application does a scsi passthru
1510                 // and sets both inlen and outlen to non-zero. ( see
1511                 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1512
1513                 cp->Request.Type.Direction = XFER_RSVD;
1514                 // This is technically wrong, and cciss controllers should
1515                 // reject it with CMD_INVALID, which is the most correct
1516                 // response, but non-fibre backends appear to let it
1517                 // slide by, and give the same results as if this field
1518                 // were set correctly.  Either way is acceptable for
1519                 // our purposes here.
1520
1521                 break;
1522
1523           default:
1524                 printk("cciss: unknown data direction: %d\n",
1525                         cmd->sc_data_direction);
1526                 BUG();
1527                 break;
1528         }
1529         cciss_scatter_gather(c, cp, cmd);
1530
1531         /* Put the request on the tail of the request queue */
1532
1533         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1534         addQ(&c->reqQ, cp);
1535         c->Qdepth++;
1536         start_io(c);
1537         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1538
1539         /* the cmd'll come back via intr handler in complete_scsi_command()  */
1540         return 0;
1541 }
1542
1543 static void
1544 cciss_unregister_scsi(int ctlr)
1545 {
1546         struct cciss_scsi_adapter_data_t *sa;
1547         struct cciss_scsi_cmd_stack_t *stk;
1548         unsigned long flags;
1549
1550         /* we are being forcibly unloaded, and may not refuse. */
1551
1552         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1553         sa = hba[ctlr]->scsi_ctlr;
1554         stk = &sa->cmd_stack;
1555
1556         /* if we weren't ever actually registered, don't unregister */
1557         if (sa->registered) {
1558                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1559                 scsi_remove_host(sa->scsi_host);
1560                 scsi_host_put(sa->scsi_host);
1561                 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1562         }
1563
1564         /* set scsi_host to NULL so our detect routine will
1565            find us on register */
1566         sa->scsi_host = NULL;
1567         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1568         scsi_cmd_stack_free(ctlr);
1569         kfree(sa);
1570 }
1571
1572 static int
1573 cciss_engage_scsi(int ctlr)
1574 {
1575         struct cciss_scsi_adapter_data_t *sa;
1576         struct cciss_scsi_cmd_stack_t *stk;
1577         unsigned long flags;
1578
1579         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1580         sa = hba[ctlr]->scsi_ctlr;
1581         stk = &sa->cmd_stack;
1582
1583         if (sa->registered) {
1584                 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1585                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1586                 return -ENXIO;
1587         }
1588         sa->registered = 1;
1589         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1590         cciss_update_non_disk_devices(ctlr, -1);
1591         cciss_scsi_detect(ctlr);
1592         return 0;
1593 }
1594
1595 static void
1596 cciss_seq_tape_report(struct seq_file *seq, int ctlr)
1597 {
1598         unsigned long flags;
1599
1600         CPQ_TAPE_LOCK(ctlr, flags);
1601         seq_printf(seq,
1602                 "Sequential access devices: %d\n\n",
1603                         ccissscsi[ctlr].ndevices);
1604         CPQ_TAPE_UNLOCK(ctlr, flags);
1605 }
1606
1607 static int wait_for_device_to_become_ready(ctlr_info_t *h,
1608         unsigned char lunaddr[])
1609 {
1610         int rc;
1611         int count = 0;
1612         int waittime = HZ;
1613         CommandList_struct *c;
1614
1615         c = cmd_alloc(h, 1);
1616         if (!c) {
1617                 printk(KERN_WARNING "cciss%d: out of memory in "
1618                         "wait_for_device_to_become_ready.\n", h->ctlr);
1619                 return IO_ERROR;
1620         }
1621
1622         /* Send test unit ready until device ready, or give up. */
1623         while (count < 20) {
1624
1625                 /* Wait for a bit.  do this first, because if we send
1626                  * the TUR right away, the reset will just abort it.
1627                  */
1628                 schedule_timeout_uninterruptible(waittime);
1629                 count++;
1630
1631                 /* Increase wait time with each try, up to a point. */
1632                 if (waittime < (HZ * 30))
1633                         waittime = waittime * 2;
1634
1635                 /* Send the Test Unit Ready */
1636                 rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
1637                         lunaddr, TYPE_CMD);
1638                 if (rc == 0)
1639                         rc = sendcmd_withirq_core(h, c, 0);
1640
1641                 (void) process_sendcmd_error(h, c);
1642
1643                 if (rc != 0)
1644                         goto retry_tur;
1645
1646                 if (c->err_info->CommandStatus == CMD_SUCCESS)
1647                         break;
1648
1649                 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1650                         c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1651                         if (c->err_info->SenseInfo[2] == NO_SENSE)
1652                                 break;
1653                         if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1654                                 unsigned char asc;
1655                                 asc = c->err_info->SenseInfo[12];
1656                                 check_for_unit_attention(h, c);
1657                                 if (asc == POWER_OR_RESET)
1658                                         break;
1659                         }
1660                 }
1661 retry_tur:
1662                 printk(KERN_WARNING "cciss%d: Waiting %d secs "
1663                         "for device to become ready.\n",
1664                         h->ctlr, waittime / HZ);
1665                 rc = 1; /* device not ready. */
1666         }
1667
1668         if (rc)
1669                 printk("cciss%d: giving up on device.\n", h->ctlr);
1670         else
1671                 printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
1672
1673         cmd_free(h, c, 1);
1674         return rc;
1675 }
1676
1677 /* Need at least one of these error handlers to keep ../scsi/hosts.c from
1678  * complaining.  Doing a host- or bus-reset can't do anything good here.
1679  * Despite what it might say in scsi_error.c, there may well be commands
1680  * on the controller, as the cciss driver registers twice, once as a block
1681  * device for the logical drives, and once as a scsi device, for any tape
1682  * drives.  So we know there are no commands out on the tape drives, but we
1683  * don't know there are no commands on the controller, and it is likely
1684  * that there probably are, as the cciss block device is most commonly used
1685  * as a boot device (embedded controller on HP/Compaq systems.)
1686 */
1687
1688 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1689 {
1690         int rc;
1691         CommandList_struct *cmd_in_trouble;
1692         unsigned char lunaddr[8];
1693         ctlr_info_t *c;
1694         int ctlr;
1695
1696         /* find the controller to which the command to be aborted was sent */
1697         c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1698         if (c == NULL) /* paranoia */
1699                 return FAILED;
1700         ctlr = c->ctlr;
1701         printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
1702         /* find the command that's giving us trouble */
1703         cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1704         if (cmd_in_trouble == NULL) /* paranoia */
1705                 return FAILED;
1706         memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1707         /* send a reset to the SCSI LUN which the command was sent to */
1708         rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
1709                 TYPE_MSG);
1710         if (rc == 0 && wait_for_device_to_become_ready(c, lunaddr) == 0)
1711                 return SUCCESS;
1712         printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
1713         return FAILED;
1714 }
1715
1716 static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1717 {
1718         int rc;
1719         CommandList_struct *cmd_to_abort;
1720         unsigned char lunaddr[8];
1721         ctlr_info_t *c;
1722         int ctlr;
1723
1724         /* find the controller to which the command to be aborted was sent */
1725         c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1726         if (c == NULL) /* paranoia */
1727                 return FAILED;
1728         ctlr = c->ctlr;
1729         printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1730
1731         /* find the command to be aborted */
1732         cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1733         if (cmd_to_abort == NULL) /* paranoia */
1734                 return FAILED;
1735         memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1736         rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
1737                 0, 0, lunaddr, TYPE_MSG);
1738         if (rc == 0)
1739                 return SUCCESS;
1740         return FAILED;
1741
1742 }
1743
1744 #else /* no CONFIG_CISS_SCSI_TAPE */
1745
1746 /* If no tape support, then these become defined out of existence */
1747
1748 #define cciss_scsi_setup(cntl_num)
1749
1750 #endif /* CONFIG_CISS_SCSI_TAPE */