drivers/block/cciss_scsi.c

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