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