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