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