drivers/block/cciss.c

   1 /*
   2  *    Disk Array driver for HP SA 5xxx and 6xxx Controllers
   3  *    Copyright 2000, 2006 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; either version 2 of the License, or
   8  *    (at your option) any later version.
   9  *
  10  *    This program is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  13  *    NON INFRINGEMENT.  See the GNU General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU General Public License
  16  *    along with this program; if not, write to the Free Software
  17  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
  20  *
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/types.h>
  26 #include <linux/pci.h>
  27 #include <linux/kernel.h>
  28 #include <linux/slab.h>
  29 #include <linux/delay.h>
  30 #include <linux/major.h>
  31 #include <linux/fs.h>
  32 #include <linux/bio.h>
  33 #include <linux/blkpg.h>
  34 #include <linux/timer.h>
  35 #include <linux/proc_fs.h>
  36 #include <linux/init.h>
  37 #include <linux/hdreg.h>
  38 #include <linux/spinlock.h>
  39 #include <linux/compat.h>
  40 #include <linux/blktrace_api.h>
  41 #include <asm/uaccess.h>
  42 #include <asm/io.h>
  43
  44 #include <linux/dma-mapping.h>
  45 #include <linux/blkdev.h>
  46 #include <linux/genhd.h>
  47 #include <linux/completion.h>
  48
  49 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
  50 #define DRIVER_NAME "HP CISS Driver (v 3.6.14)"
  51 #define DRIVER_VERSION CCISS_DRIVER_VERSION(3,6,14)
  52
  53 /* Embedded module documentation macros - see modules.h */
  54 MODULE_AUTHOR("Hewlett-Packard Company");
  55 MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 3.6.14");
  56 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
  57                         " SA6i P600 P800 P400 P400i E200 E200i E500");
  58 MODULE_VERSION("3.6.14");
  59 MODULE_LICENSE("GPL");
  60
  61 #include "cciss_cmd.h"
  62 #include "cciss.h"
  63 #include <linux/cciss_ioctl.h>
  64
  65 /* define the PCI info for the cards we can control */
  66 static const struct pci_device_id cciss_pci_device_id[] = {
  67         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,  0x0E11, 0x4070},
  68         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
  69         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
  70         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
  71         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
  72         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
  73         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
  74         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
  75         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
  76         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSA,     0x103C, 0x3225},
  77         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3223},
  78         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3234},
  79         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3235},
  80         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3211},
  81         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3212},
  82         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3213},
  83         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3214},
  84         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3215},
  85         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3237},
  86         {PCI_VENDOR_ID_HP,     PCI_ANY_ID,      PCI_ANY_ID, PCI_ANY_ID,
  87                 PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},
  88         {0,}
  89 };
  90
  91 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
  92
  93 /*  board_id = Subsystem Device ID & Vendor ID
  94  *  product = Marketing Name for the board
  95  *  access = Address of the struct of function pointers
  96  *  nr_cmds = Number of commands supported by controller
  97  */
  98 static struct board_type products[] = {
  99         {0x40700E11, "Smart Array 5300", &SA5_access, 512},
 100         {0x40800E11, "Smart Array 5i", &SA5B_access, 512},
 101         {0x40820E11, "Smart Array 532", &SA5B_access, 512},
 102         {0x40830E11, "Smart Array 5312", &SA5B_access, 512},
 103         {0x409A0E11, "Smart Array 641", &SA5_access, 512},
 104         {0x409B0E11, "Smart Array 642", &SA5_access, 512},
 105         {0x409C0E11, "Smart Array 6400", &SA5_access, 512},
 106         {0x409D0E11, "Smart Array 6400 EM", &SA5_access, 512},
 107         {0x40910E11, "Smart Array 6i", &SA5_access, 512},
 108         {0x3225103C, "Smart Array P600", &SA5_access, 512},
 109         {0x3223103C, "Smart Array P800", &SA5_access, 512},
 110         {0x3234103C, "Smart Array P400", &SA5_access, 512},
 111         {0x3235103C, "Smart Array P400i", &SA5_access, 512},
 112         {0x3211103C, "Smart Array E200i", &SA5_access, 120},
 113         {0x3212103C, "Smart Array E200", &SA5_access, 120},
 114         {0x3213103C, "Smart Array E200i", &SA5_access, 120},
 115         {0x3214103C, "Smart Array E200i", &SA5_access, 120},
 116         {0x3215103C, "Smart Array E200i", &SA5_access, 120},
 117         {0x3237103C, "Smart Array E500", &SA5_access, 512},
 118         {0xFFFF103C, "Unknown Smart Array", &SA5_access, 120},
 119 };
 120
 121 /* How long to wait (in milliseconds) for board to go into simple mode */
 122 #define MAX_CONFIG_WAIT 30000
 123 #define MAX_IOCTL_CONFIG_WAIT 1000
 124
 125 /*define how many times we will try a command because of bus resets */
 126 #define MAX_CMD_RETRIES 3
 127
 128 #define READ_AHEAD       1024
 129 #define MAX_CTLR        32
 130
 131 /* Originally cciss driver only supports 8 major numbers */
 132 #define MAX_CTLR_ORIG   8
 133
 134 static ctlr_info_t *hba[MAX_CTLR];
 135
 136 static void do_cciss_request(request_queue_t *q);
 137 static irqreturn_t do_cciss_intr(int irq, void *dev_id);
 138 static int cciss_open(struct inode *inode, struct file *filep);
 139 static int cciss_release(struct inode *inode, struct file *filep);
 140 static int cciss_ioctl(struct inode *inode, struct file *filep,
 141                        unsigned int cmd, unsigned long arg);
 142 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 143
 144 static int cciss_revalidate(struct gendisk *disk);
 145 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
 146 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
 147                            int clear_all);
 148
 149 static void cciss_read_capacity(int ctlr, int logvol, int withirq,
 150                         sector_t *total_size, unsigned int *block_size);
 151 static void cciss_read_capacity_16(int ctlr, int logvol, int withirq,
 152                         sector_t *total_size, unsigned int *block_size);
 153 static void cciss_geometry_inquiry(int ctlr, int logvol,
 154                         int withirq, sector_t total_size,
 155                         unsigned int block_size, InquiryData_struct *inq_buff,
 156                                    drive_info_struct *drv);
 157 static void cciss_getgeometry(int cntl_num);
 158 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
 159                                            __u32);
 160 static void start_io(ctlr_info_t *h);
 161 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
 162                    unsigned int use_unit_num, unsigned int log_unit,
 163                    __u8 page_code, unsigned char *scsi3addr, int cmd_type);
 164 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
 165                            unsigned int use_unit_num, unsigned int log_unit,
 166                            __u8 page_code, int cmd_type);
 167
 168 static void fail_all_cmds(unsigned long ctlr);
 169
 170 #ifdef CONFIG_PROC_FS
 171 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
 172                                int length, int *eof, void *data);
 173 static void cciss_procinit(int i);
 174 #else
 175 static void cciss_procinit(int i)
 176 {
 177 }
 178 #endif                          /* CONFIG_PROC_FS */
 179
 180 #ifdef CONFIG_COMPAT
 181 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
 182 #endif
 183
 184 static struct block_device_operations cciss_fops = {
 185         .owner = THIS_MODULE,
 186         .open = cciss_open,
 187         .release = cciss_release,
 188         .ioctl = cciss_ioctl,
 189         .getgeo = cciss_getgeo,
 190 #ifdef CONFIG_COMPAT
 191         .compat_ioctl = cciss_compat_ioctl,
 192 #endif
 193         .revalidate_disk = cciss_revalidate,
 194 };
 195
 196 /*
 197  * Enqueuing and dequeuing functions for cmdlists.
 198  */
 199 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
 200 {
 201         if (*Qptr == NULL) {
 202                 *Qptr = c;
 203                 c->next = c->prev = c;
 204         } else {
 205                 c->prev = (*Qptr)->prev;
 206                 c->next = (*Qptr);
 207                 (*Qptr)->prev->next = c;
 208                 (*Qptr)->prev = c;
 209         }
 210 }
 211
 212 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
 213                                           CommandList_struct *c)
 214 {
 215         if (c && c->next != c) {
 216                 if (*Qptr == c)
 217                         *Qptr = c->next;
 218                 c->prev->next = c->next;
 219                 c->next->prev = c->prev;
 220         } else {
 221                 *Qptr = NULL;
 222         }
 223         return c;
 224 }
 225
 226 #include "cciss_scsi.c"         /* For SCSI tape support */
 227
 228 #ifdef CONFIG_PROC_FS
 229
 230 /*
 231  * Report information about this controller.
 232  */
 233 #define ENG_GIG 1000000000
 234 #define ENG_GIG_FACTOR (ENG_GIG/512)
 235 #define RAID_UNKNOWN 6
 236 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
 237         "UNKNOWN"
 238 };
 239
 240 static struct proc_dir_entry *proc_cciss;
 241
 242 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
 243                                int length, int *eof, void *data)
 244 {
 245         off_t pos = 0;
 246         off_t len = 0;
 247         int size, i, ctlr;
 248         ctlr_info_t *h = (ctlr_info_t *) data;
 249         drive_info_struct *drv;
 250         unsigned long flags;
 251         sector_t vol_sz, vol_sz_frac;
 252
 253         ctlr = h->ctlr;
 254
 255         /* prevent displaying bogus info during configuration
 256          * or deconfiguration of a logical volume
 257          */
 258         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 259         if (h->busy_configuring) {
 260                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 261                 return -EBUSY;
 262         }
 263         h->busy_configuring = 1;
 264         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 265
 266         size = sprintf(buffer, "%s: HP %s Controller\n"
 267                        "Board ID: 0x%08lx\n"
 268                        "Firmware Version: %c%c%c%c\n"
 269                        "IRQ: %d\n"
 270                        "Logical drives: %d\n"
 271                        "Max sectors: %d\n"
 272                        "Current Q depth: %d\n"
 273                        "Current # commands on controller: %d\n"
 274                        "Max Q depth since init: %d\n"
 275                        "Max # commands on controller since init: %d\n"
 276                        "Max SG entries since init: %d\n\n",
 277                        h->devname,
 278                        h->product_name,
 279                        (unsigned long)h->board_id,
 280                        h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
 281                        h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
 282                        h->num_luns,
 283                        h->cciss_max_sectors,
 284                        h->Qdepth, h->commands_outstanding,
 285                        h->maxQsinceinit, h->max_outstanding, h->maxSG);
 286
 287         pos += size;
 288         len += size;
 289         cciss_proc_tape_report(ctlr, buffer, &pos, &len);
 290         for (i = 0; i <= h->highest_lun; i++) {
 291
 292                 drv = &h->drv[i];
 293                 if (drv->heads == 0)
 294                         continue;
 295
 296                 vol_sz = drv->nr_blocks;
 297                 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
 298                 vol_sz_frac *= 100;
 299                 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
 300
 301                 if (drv->raid_level > 5)
 302                         drv->raid_level = RAID_UNKNOWN;
 303                 size = sprintf(buffer + len, "cciss/c%dd%d:"
 304                                "\t%4u.%02uGB\tRAID %s\n",
 305                                ctlr, i, (int)vol_sz, (int)vol_sz_frac,
 306                                raid_label[drv->raid_level]);
 307                 pos += size;
 308                 len += size;
 309         }
 310
 311         *eof = 1;
 312         *start = buffer + offset;
 313         len -= offset;
 314         if (len > length)
 315                 len = length;
 316         h->busy_configuring = 0;
 317         return len;
 318 }
 319
 320 static int
 321 cciss_proc_write(struct file *file, const char __user *buffer,
 322                  unsigned long count, void *data)
 323 {
 324         unsigned char cmd[80];
 325         int len;
 326 #ifdef CONFIG_CISS_SCSI_TAPE
 327         ctlr_info_t *h = (ctlr_info_t *) data;
 328         int rc;
 329 #endif
 330
 331         if (count > sizeof(cmd) - 1)
 332                 return -EINVAL;
 333         if (copy_from_user(cmd, buffer, count))
 334                 return -EFAULT;
 335         cmd[count] = '\0';
 336         len = strlen(cmd);      // above 3 lines ensure safety
 337         if (len && cmd[len - 1] == '\n')
 338                 cmd[--len] = '\0';
 339 #       ifdef CONFIG_CISS_SCSI_TAPE
 340         if (strcmp("engage scsi", cmd) == 0) {
 341                 rc = cciss_engage_scsi(h->ctlr);
 342                 if (rc != 0)
 343                         return -rc;
 344                 return count;
 345         }
 346         /* might be nice to have "disengage" too, but it's not
 347            safely possible. (only 1 module use count, lock issues.) */
 348 #       endif
 349         return -EINVAL;
 350 }
 351
 352 /*
 353  * Get us a file in /proc/cciss that says something about each controller.
 354  * Create /proc/cciss if it doesn't exist yet.
 355  */
 356 static void __devinit cciss_procinit(int i)
 357 {
 358         struct proc_dir_entry *pde;
 359
 360         if (proc_cciss == NULL) {
 361                 proc_cciss = proc_mkdir("cciss", proc_root_driver);
 362                 if (!proc_cciss)
 363                         return;
 364         }
 365
 366         pde = create_proc_read_entry(hba[i]->devname,
 367                                      S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
 368                                      proc_cciss, cciss_proc_get_info, hba[i]);
 369         pde->write_proc = cciss_proc_write;
 370 }
 371 #endif                          /* CONFIG_PROC_FS */
 372
 373 /*
 374  * For operations that cannot sleep, a command block is allocated at init,
 375  * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
 376  * which ones are free or in use.  For operations that can wait for kmalloc
 377  * to possible sleep, this routine can be called with get_from_pool set to 0.
 378  * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
 379  */
 380 static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
 381 {
 382         CommandList_struct *c;
 383         int i;
 384         u64bit temp64;
 385         dma_addr_t cmd_dma_handle, err_dma_handle;
 386
 387         if (!get_from_pool) {
 388                 c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
 389                         sizeof(CommandList_struct), &cmd_dma_handle);
 390                 if (c == NULL)
 391                         return NULL;
 392                 memset(c, 0, sizeof(CommandList_struct));
 393
 394                 c->cmdindex = -1;
 395
 396                 c->err_info = (ErrorInfo_struct *)
 397                     pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
 398                             &err_dma_handle);
 399
 400                 if (c->err_info == NULL) {
 401                         pci_free_consistent(h->pdev,
 402                                 sizeof(CommandList_struct), c, cmd_dma_handle);
 403                         return NULL;
 404                 }
 405                 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
 406         } else {                /* get it out of the controllers pool */
 407
 408                 do {
 409                         i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
 410                         if (i == h->nr_cmds)
 411                                 return NULL;
 412                 } while (test_and_set_bit
 413                          (i & (BITS_PER_LONG - 1),
 414                           h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
 415 #ifdef CCISS_DEBUG
 416                 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
 417 #endif
 418                 c = h->cmd_pool + i;
 419                 memset(c, 0, sizeof(CommandList_struct));
 420                 cmd_dma_handle = h->cmd_pool_dhandle
 421                     + i * sizeof(CommandList_struct);
 422                 c->err_info = h->errinfo_pool + i;
 423                 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
 424                 err_dma_handle = h->errinfo_pool_dhandle
 425                     + i * sizeof(ErrorInfo_struct);
 426                 h->nr_allocs++;
 427
 428                 c->cmdindex = i;
 429         }
 430
 431         c->busaddr = (__u32) cmd_dma_handle;
 432         temp64.val = (__u64) err_dma_handle;
 433         c->ErrDesc.Addr.lower = temp64.val32.lower;
 434         c->ErrDesc.Addr.upper = temp64.val32.upper;
 435         c->ErrDesc.Len = sizeof(ErrorInfo_struct);
 436
 437         c->ctlr = h->ctlr;
 438         return c;
 439 }
 440
 441 /*
 442  * Frees a command block that was previously allocated with cmd_alloc().
 443  */
 444 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
 445 {
 446         int i;
 447         u64bit temp64;
 448
 449         if (!got_from_pool) {
 450                 temp64.val32.lower = c->ErrDesc.Addr.lower;
 451                 temp64.val32.upper = c->ErrDesc.Addr.upper;
 452                 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
 453                                     c->err_info, (dma_addr_t) temp64.val);
 454                 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
 455                                     c, (dma_addr_t) c->busaddr);
 456         } else {
 457                 i = c - h->cmd_pool;
 458                 clear_bit(i & (BITS_PER_LONG - 1),
 459                           h->cmd_pool_bits + (i / BITS_PER_LONG));
 460                 h->nr_frees++;
 461         }
 462 }
 463
 464 static inline ctlr_info_t *get_host(struct gendisk *disk)
 465 {
 466         return disk->queue->queuedata;
 467 }
 468
 469 static inline drive_info_struct *get_drv(struct gendisk *disk)
 470 {
 471         return disk->private_data;
 472 }
 473
 474 /*
 475  * Open.  Make sure the device is really there.
 476  */
 477 static int cciss_open(struct inode *inode, struct file *filep)
 478 {
 479         ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
 480         drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
 481
 482 #ifdef CCISS_DEBUG
 483         printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
 484 #endif                          /* CCISS_DEBUG */
 485
 486         if (host->busy_initializing || drv->busy_configuring)
 487                 return -EBUSY;
 488         /*
 489          * Root is allowed to open raw volume zero even if it's not configured
 490          * so array config can still work. Root is also allowed to open any
 491          * volume that has a LUN ID, so it can issue IOCTL to reread the
 492          * disk information.  I don't think I really like this
 493          * but I'm already using way to many device nodes to claim another one
 494          * for "raw controller".
 495          */
 496         if (drv->heads == 0) {
 497                 if (iminor(inode) != 0) {       /* not node 0? */
 498                         /* if not node 0 make sure it is a partition = 0 */
 499                         if (iminor(inode) & 0x0f) {
 500                                 return -ENXIO;
 501                                 /* if it is, make sure we have a LUN ID */
 502                         } else if (drv->LunID == 0) {
 503                                 return -ENXIO;
 504                         }
 505                 }
 506                 if (!capable(CAP_SYS_ADMIN))
 507                         return -EPERM;
 508         }
 509         drv->usage_count++;
 510         host->usage_count++;
 511         return 0;
 512 }
 513
 514 /*
 515  * Close.  Sync first.
 516  */
 517 static int cciss_release(struct inode *inode, struct file *filep)
 518 {
 519         ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
 520         drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
 521
 522 #ifdef CCISS_DEBUG
 523         printk(KERN_DEBUG "cciss_release %s\n",
 524                inode->i_bdev->bd_disk->disk_name);
 525 #endif                          /* CCISS_DEBUG */
 526
 527         drv->usage_count--;
 528         host->usage_count--;
 529         return 0;
 530 }
 531
 532 #ifdef CONFIG_COMPAT
 533
 534 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 535 {
 536         int ret;
 537         lock_kernel();
 538         ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
 539         unlock_kernel();
 540         return ret;
 541 }
 542
 543 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
 544                                   unsigned long arg);
 545 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
 546                                       unsigned long arg);
 547
 548 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 549 {
 550         switch (cmd) {
 551         case CCISS_GETPCIINFO:
 552         case CCISS_GETINTINFO:
 553         case CCISS_SETINTINFO:
 554         case CCISS_GETNODENAME:
 555         case CCISS_SETNODENAME:
 556         case CCISS_GETHEARTBEAT:
 557         case CCISS_GETBUSTYPES:
 558         case CCISS_GETFIRMVER:
 559         case CCISS_GETDRIVVER:
 560         case CCISS_REVALIDVOLS:
 561         case CCISS_DEREGDISK:
 562         case CCISS_REGNEWDISK:
 563         case CCISS_REGNEWD:
 564         case CCISS_RESCANDISK:
 565         case CCISS_GETLUNINFO:
 566                 return do_ioctl(f, cmd, arg);
 567
 568         case CCISS_PASSTHRU32:
 569                 return cciss_ioctl32_passthru(f, cmd, arg);
 570         case CCISS_BIG_PASSTHRU32:
 571                 return cciss_ioctl32_big_passthru(f, cmd, arg);
 572
 573         default:
 574                 return -ENOIOCTLCMD;
 575         }
 576 }
 577
 578 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
 579                                   unsigned long arg)
 580 {
 581         IOCTL32_Command_struct __user *arg32 =
 582             (IOCTL32_Command_struct __user *) arg;
 583         IOCTL_Command_struct arg64;
 584         IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
 585         int err;
 586         u32 cp;
 587
 588         err = 0;
 589         err |=
 590             copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
 591                            sizeof(arg64.LUN_info));
 592         err |=
 593             copy_from_user(&arg64.Request, &arg32->Request,
 594                            sizeof(arg64.Request));
 595         err |=
 596             copy_from_user(&arg64.error_info, &arg32->error_info,
 597                            sizeof(arg64.error_info));
 598         err |= get_user(arg64.buf_size, &arg32->buf_size);
 599         err |= get_user(cp, &arg32->buf);
 600         arg64.buf = compat_ptr(cp);
 601         err |= copy_to_user(p, &arg64, sizeof(arg64));
 602
 603         if (err)
 604                 return -EFAULT;
 605
 606         err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p);
 607         if (err)
 608                 return err;
 609         err |=
 610             copy_in_user(&arg32->error_info, &p->error_info,
 611                          sizeof(arg32->error_info));
 612         if (err)
 613                 return -EFAULT;
 614         return err;
 615 }
 616
 617 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
 618                                       unsigned long arg)
 619 {
 620         BIG_IOCTL32_Command_struct __user *arg32 =
 621             (BIG_IOCTL32_Command_struct __user *) arg;
 622         BIG_IOCTL_Command_struct arg64;
 623         BIG_IOCTL_Command_struct __user *p =
 624             compat_alloc_user_space(sizeof(arg64));
 625         int err;
 626         u32 cp;
 627
 628         err = 0;
 629         err |=
 630             copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
 631                            sizeof(arg64.LUN_info));
 632         err |=
 633             copy_from_user(&arg64.Request, &arg32->Request,
 634                            sizeof(arg64.Request));
 635         err |=
 636             copy_from_user(&arg64.error_info, &arg32->error_info,
 637                            sizeof(arg64.error_info));
 638         err |= get_user(arg64.buf_size, &arg32->buf_size);
 639         err |= get_user(arg64.malloc_size, &arg32->malloc_size);
 640         err |= get_user(cp, &arg32->buf);
 641         arg64.buf = compat_ptr(cp);
 642         err |= copy_to_user(p, &arg64, sizeof(arg64));
 643
 644         if (err)
 645                 return -EFAULT;
 646
 647         err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);
 648         if (err)
 649                 return err;
 650         err |=
 651             copy_in_user(&arg32->error_info, &p->error_info,
 652                          sizeof(arg32->error_info));
 653         if (err)
 654                 return -EFAULT;
 655         return err;
 656 }
 657 #endif
 658
 659 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 660 {
 661         drive_info_struct *drv = get_drv(bdev->bd_disk);
 662
 663         if (!drv->cylinders)
 664                 return -ENXIO;
 665
 666         geo->heads = drv->heads;
 667         geo->sectors = drv->sectors;
 668         geo->cylinders = drv->cylinders;
 669         return 0;
 670 }
 671
 672 /*
 673  * ioctl
 674  */
 675 static int cciss_ioctl(struct inode *inode, struct file *filep,
 676                        unsigned int cmd, unsigned long arg)
 677 {
 678         struct block_device *bdev = inode->i_bdev;
 679         struct gendisk *disk = bdev->bd_disk;
 680         ctlr_info_t *host = get_host(disk);
 681         drive_info_struct *drv = get_drv(disk);
 682         int ctlr = host->ctlr;
 683         void __user *argp = (void __user *)arg;
 684
 685 #ifdef CCISS_DEBUG
 686         printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
 687 #endif                          /* CCISS_DEBUG */
 688
 689         switch (cmd) {
 690         case CCISS_GETPCIINFO:
 691                 {
 692                         cciss_pci_info_struct pciinfo;
 693
 694                         if (!arg)
 695                                 return -EINVAL;
 696                         pciinfo.domain = pci_domain_nr(host->pdev->bus);
 697                         pciinfo.bus = host->pdev->bus->number;
 698                         pciinfo.dev_fn = host->pdev->devfn;
 699                         pciinfo.board_id = host->board_id;
 700                         if (copy_to_user
 701                             (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
 702                                 return -EFAULT;
 703                         return 0;
 704                 }
 705         case CCISS_GETINTINFO:
 706                 {
 707                         cciss_coalint_struct intinfo;
 708                         if (!arg)
 709                                 return -EINVAL;
 710                         intinfo.delay =
 711                             readl(&host->cfgtable->HostWrite.CoalIntDelay);
 712                         intinfo.count =
 713                             readl(&host->cfgtable->HostWrite.CoalIntCount);
 714                         if (copy_to_user
 715                             (argp, &intinfo, sizeof(cciss_coalint_struct)))
 716                                 return -EFAULT;
 717                         return 0;
 718                 }
 719         case CCISS_SETINTINFO:
 720                 {
 721                         cciss_coalint_struct intinfo;
 722                         unsigned long flags;
 723                         int i;
 724
 725                         if (!arg)
 726                                 return -EINVAL;
 727                         if (!capable(CAP_SYS_ADMIN))
 728                                 return -EPERM;
 729                         if (copy_from_user
 730                             (&intinfo, argp, sizeof(cciss_coalint_struct)))
 731                                 return -EFAULT;
 732                         if ((intinfo.delay == 0) && (intinfo.count == 0))
 733                         {
 734 //                      printk("cciss_ioctl: delay and count cannot be 0\n");
 735                                 return -EINVAL;
 736                         }
 737                         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 738                         /* Update the field, and then ring the doorbell */
 739                         writel(intinfo.delay,
 740                                &(host->cfgtable->HostWrite.CoalIntDelay));
 741                         writel(intinfo.count,
 742                                &(host->cfgtable->HostWrite.CoalIntCount));
 743                         writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
 744
 745                         for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
 746                                 if (!(readl(host->vaddr + SA5_DOORBELL)
 747                                       & CFGTBL_ChangeReq))
 748                                         break;
 749                                 /* delay and try again */
 750                                 udelay(1000);
 751                         }
 752                         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 753                         if (i >= MAX_IOCTL_CONFIG_WAIT)
 754                                 return -EAGAIN;
 755                         return 0;
 756                 }
 757         case CCISS_GETNODENAME:
 758                 {
 759                         NodeName_type NodeName;
 760                         int i;
 761
 762                         if (!arg)
 763                                 return -EINVAL;
 764                         for (i = 0; i < 16; i++)
 765                                 NodeName[i] =
 766                                     readb(&host->cfgtable->ServerName[i]);
 767                         if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
 768                                 return -EFAULT;
 769                         return 0;
 770                 }
 771         case CCISS_SETNODENAME:
 772                 {
 773                         NodeName_type NodeName;
 774                         unsigned long flags;
 775                         int i;
 776
 777                         if (!arg)
 778                                 return -EINVAL;
 779                         if (!capable(CAP_SYS_ADMIN))
 780                                 return -EPERM;
 781
 782                         if (copy_from_user
 783                             (NodeName, argp, sizeof(NodeName_type)))
 784                                 return -EFAULT;
 785
 786                         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 787
 788                         /* Update the field, and then ring the doorbell */
 789                         for (i = 0; i < 16; i++)
 790                                 writeb(NodeName[i],
 791                                        &host->cfgtable->ServerName[i]);
 792
 793                         writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
 794
 795                         for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
 796                                 if (!(readl(host->vaddr + SA5_DOORBELL)
 797                                       & CFGTBL_ChangeReq))
 798                                         break;
 799                                 /* delay and try again */
 800                                 udelay(1000);
 801                         }
 802                         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 803                         if (i >= MAX_IOCTL_CONFIG_WAIT)
 804                                 return -EAGAIN;
 805                         return 0;
 806                 }
 807
 808         case CCISS_GETHEARTBEAT:
 809                 {
 810                         Heartbeat_type heartbeat;
 811
 812                         if (!arg)
 813                                 return -EINVAL;
 814                         heartbeat = readl(&host->cfgtable->HeartBeat);
 815                         if (copy_to_user
 816                             (argp, &heartbeat, sizeof(Heartbeat_type)))
 817                                 return -EFAULT;
 818                         return 0;
 819                 }
 820         case CCISS_GETBUSTYPES:
 821                 {
 822                         BusTypes_type BusTypes;
 823
 824                         if (!arg)
 825                                 return -EINVAL;
 826                         BusTypes = readl(&host->cfgtable->BusTypes);
 827                         if (copy_to_user
 828                             (argp, &BusTypes, sizeof(BusTypes_type)))
 829                                 return -EFAULT;
 830                         return 0;
 831                 }
 832         case CCISS_GETFIRMVER:
 833                 {
 834                         FirmwareVer_type firmware;
 835
 836                         if (!arg)
 837                                 return -EINVAL;
 838                         memcpy(firmware, host->firm_ver, 4);
 839
 840                         if (copy_to_user
 841                             (argp, firmware, sizeof(FirmwareVer_type)))
 842                                 return -EFAULT;
 843                         return 0;
 844                 }
 845         case CCISS_GETDRIVVER:
 846                 {
 847                         DriverVer_type DriverVer = DRIVER_VERSION;
 848
 849                         if (!arg)
 850                                 return -EINVAL;
 851
 852                         if (copy_to_user
 853                             (argp, &DriverVer, sizeof(DriverVer_type)))
 854                                 return -EFAULT;
 855                         return 0;
 856                 }
 857
 858         case CCISS_REVALIDVOLS:
 859                 return rebuild_lun_table(host, NULL);
 860
 861         case CCISS_GETLUNINFO:{
 862                         LogvolInfo_struct luninfo;
 863
 864                         luninfo.LunID = drv->LunID;
 865                         luninfo.num_opens = drv->usage_count;
 866                         luninfo.num_parts = 0;
 867                         if (copy_to_user(argp, &luninfo,
 868                                          sizeof(LogvolInfo_struct)))
 869                                 return -EFAULT;
 870                         return 0;
 871                 }
 872         case CCISS_DEREGDISK:
 873                 return rebuild_lun_table(host, disk);
 874
 875         case CCISS_REGNEWD:
 876                 return rebuild_lun_table(host, NULL);
 877
 878         case CCISS_PASSTHRU:
 879                 {
 880                         IOCTL_Command_struct iocommand;
 881                         CommandList_struct *c;
 882                         char *buff = NULL;
 883                         u64bit temp64;
 884                         unsigned long flags;
 885                         DECLARE_COMPLETION_ONSTACK(wait);
 886
 887                         if (!arg)
 888                                 return -EINVAL;
 889
 890                         if (!capable(CAP_SYS_RAWIO))
 891                                 return -EPERM;
 892
 893                         if (copy_from_user
 894                             (&iocommand, argp, sizeof(IOCTL_Command_struct)))
 895                                 return -EFAULT;
 896                         if ((iocommand.buf_size < 1) &&
 897                             (iocommand.Request.Type.Direction != XFER_NONE)) {
 898                                 return -EINVAL;
 899                         }
 900 #if 0                           /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
 901                         /* Check kmalloc limits */
 902                         if (iocommand.buf_size > 128000)
 903                                 return -EINVAL;
 904 #endif
 905                         if (iocommand.buf_size > 0) {
 906                                 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
 907                                 if (buff == NULL)
 908                                         return -EFAULT;
 909                         }
 910                         if (iocommand.Request.Type.Direction == XFER_WRITE) {
 911                                 /* Copy the data into the buffer we created */
 912                                 if (copy_from_user
 913                                     (buff, iocommand.buf, iocommand.buf_size)) {
 914                                         kfree(buff);
 915                                         return -EFAULT;
 916                                 }
 917                         } else {
 918                                 memset(buff, 0, iocommand.buf_size);
 919                         }
 920                         if ((c = cmd_alloc(host, 0)) == NULL) {
 921                                 kfree(buff);
 922                                 return -ENOMEM;
 923                         }
 924                         // Fill in the command type
 925                         c->cmd_type = CMD_IOCTL_PEND;
 926                         // Fill in Command Header
 927                         c->Header.ReplyQueue = 0;       // unused in simple mode
 928                         if (iocommand.buf_size > 0)     // buffer to fill
 929                         {
 930                                 c->Header.SGList = 1;
 931                                 c->Header.SGTotal = 1;
 932                         } else  // no buffers to fill
 933                         {
 934                                 c->Header.SGList = 0;
 935                                 c->Header.SGTotal = 0;
 936                         }
 937                         c->Header.LUN = iocommand.LUN_info;
 938                         c->Header.Tag.lower = c->busaddr;       // use the kernel address the cmd block for tag
 939
 940                         // Fill in Request block
 941                         c->Request = iocommand.Request;
 942
 943                         // Fill in the scatter gather information
 944                         if (iocommand.buf_size > 0) {
 945                                 temp64.val = pci_map_single(host->pdev, buff,
 946                                         iocommand.buf_size,
 947                                         PCI_DMA_BIDIRECTIONAL);
 948                                 c->SG[0].Addr.lower = temp64.val32.lower;
 949                                 c->SG[0].Addr.upper = temp64.val32.upper;
 950                                 c->SG[0].Len = iocommand.buf_size;
 951                                 c->SG[0].Ext = 0;       // we are not chaining
 952                         }
 953                         c->waiting = &wait;
 954
 955                         /* Put the request on the tail of the request queue */
 956                         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 957                         addQ(&host->reqQ, c);
 958                         host->Qdepth++;
 959                         start_io(host);
 960                         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 961
 962                         wait_for_completion(&wait);
 963
 964                         /* unlock the buffers from DMA */
 965                         temp64.val32.lower = c->SG[0].Addr.lower;
 966                         temp64.val32.upper = c->SG[0].Addr.upper;
 967                         pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
 968                                          iocommand.buf_size,
 969                                          PCI_DMA_BIDIRECTIONAL);
 970
 971                         /* Copy the error information out */
 972                         iocommand.error_info = *(c->err_info);
 973                         if (copy_to_user
 974                             (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
 975                                 kfree(buff);
 976                                 cmd_free(host, c, 0);
 977                                 return -EFAULT;
 978                         }
 979
 980                         if (iocommand.Request.Type.Direction == XFER_READ) {
 981                                 /* Copy the data out of the buffer we created */
 982                                 if (copy_to_user
 983                                     (iocommand.buf, buff, iocommand.buf_size)) {
 984                                         kfree(buff);
 985                                         cmd_free(host, c, 0);
 986                                         return -EFAULT;
 987                                 }
 988                         }
 989                         kfree(buff);
 990                         cmd_free(host, c, 0);
 991                         return 0;
 992                 }
 993         case CCISS_BIG_PASSTHRU:{
 994                         BIG_IOCTL_Command_struct *ioc;
 995                         CommandList_struct *c;
 996                         unsigned char **buff = NULL;
 997                         int *buff_size = NULL;
 998                         u64bit temp64;
 999                         unsigned long flags;
1000                         BYTE sg_used = 0;
1001                         int status = 0;
1002                         int i;
1003                         DECLARE_COMPLETION_ONSTACK(wait);
1004                         __u32 left;
1005                         __u32 sz;
1006                         BYTE __user *data_ptr;
1007
1008                         if (!arg)
1009                                 return -EINVAL;
1010                         if (!capable(CAP_SYS_RAWIO))
1011                                 return -EPERM;
1012                         ioc = (BIG_IOCTL_Command_struct *)
1013                             kmalloc(sizeof(*ioc), GFP_KERNEL);
1014                         if (!ioc) {
1015                                 status = -ENOMEM;
1016                                 goto cleanup1;
1017                         }
1018                         if (copy_from_user(ioc, argp, sizeof(*ioc))) {
1019                                 status = -EFAULT;
1020                                 goto cleanup1;
1021                         }
1022                         if ((ioc->buf_size < 1) &&
1023                             (ioc->Request.Type.Direction != XFER_NONE)) {
1024                                 status = -EINVAL;
1025                                 goto cleanup1;
1026                         }
1027                         /* Check kmalloc limits  using all SGs */
1028                         if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
1029                                 status = -EINVAL;
1030                                 goto cleanup1;
1031                         }
1032                         if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
1033                                 status = -EINVAL;
1034                                 goto cleanup1;
1035                         }
1036                         buff =
1037                             kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
1038                         if (!buff) {
1039                                 status = -ENOMEM;
1040                                 goto cleanup1;
1041                         }
1042                         buff_size = (int *)kmalloc(MAXSGENTRIES * sizeof(int),
1043                                                    GFP_KERNEL);
1044                         if (!buff_size) {
1045                                 status = -ENOMEM;
1046                                 goto cleanup1;
1047                         }
1048                         left = ioc->buf_size;
1049                         data_ptr = ioc->buf;
1050                         while (left) {
1051                                 sz = (left >
1052                                       ioc->malloc_size) ? ioc->
1053                                     malloc_size : left;
1054                                 buff_size[sg_used] = sz;
1055                                 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1056                                 if (buff[sg_used] == NULL) {
1057                                         status = -ENOMEM;
1058                                         goto cleanup1;
1059                                 }
1060                                 if (ioc->Request.Type.Direction == XFER_WRITE) {
1061                                         if (copy_from_user
1062                                             (buff[sg_used], data_ptr, sz)) {
1063                                                 status = -ENOMEM;
1064                                                 goto cleanup1;
1065                                         }
1066                                 } else {
1067                                         memset(buff[sg_used], 0, sz);
1068                                 }
1069                                 left -= sz;
1070                                 data_ptr += sz;
1071                                 sg_used++;
1072                         }
1073                         if ((c = cmd_alloc(host, 0)) == NULL) {
1074                                 status = -ENOMEM;
1075                                 goto cleanup1;
1076                         }
1077                         c->cmd_type = CMD_IOCTL_PEND;
1078                         c->Header.ReplyQueue = 0;
1079
1080                         if (ioc->buf_size > 0) {
1081                                 c->Header.SGList = sg_used;
1082                                 c->Header.SGTotal = sg_used;
1083                         } else {
1084                                 c->Header.SGList = 0;
1085                                 c->Header.SGTotal = 0;
1086                         }
1087                         c->Header.LUN = ioc->LUN_info;
1088                         c->Header.Tag.lower = c->busaddr;
1089
1090                         c->Request = ioc->Request;
1091                         if (ioc->buf_size > 0) {
1092                                 int i;
1093                                 for (i = 0; i < sg_used; i++) {
1094                                         temp64.val =
1095                                             pci_map_single(host->pdev, buff[i],
1096                                                     buff_size[i],
1097                                                     PCI_DMA_BIDIRECTIONAL);
1098                                         c->SG[i].Addr.lower =
1099                                             temp64.val32.lower;
1100                                         c->SG[i].Addr.upper =
1101                                             temp64.val32.upper;
1102                                         c->SG[i].Len = buff_size[i];
1103                                         c->SG[i].Ext = 0;       /* we are not chaining */
1104                                 }
1105                         }
1106                         c->waiting = &wait;
1107                         /* Put the request on the tail of the request queue */
1108                         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1109                         addQ(&host->reqQ, c);
1110                         host->Qdepth++;
1111                         start_io(host);
1112                         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1113                         wait_for_completion(&wait);
1114                         /* unlock the buffers from DMA */
1115                         for (i = 0; i < sg_used; i++) {
1116                                 temp64.val32.lower = c->SG[i].Addr.lower;
1117                                 temp64.val32.upper = c->SG[i].Addr.upper;
1118                                 pci_unmap_single(host->pdev,
1119                                         (dma_addr_t) temp64.val, buff_size[i],
1120                                         PCI_DMA_BIDIRECTIONAL);
1121                         }
1122                         /* Copy the error information out */
1123                         ioc->error_info = *(c->err_info);
1124                         if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1125                                 cmd_free(host, c, 0);
1126                                 status = -EFAULT;
1127                                 goto cleanup1;
1128                         }
1129                         if (ioc->Request.Type.Direction == XFER_READ) {
1130                                 /* Copy the data out of the buffer we created */
1131                                 BYTE __user *ptr = ioc->buf;
1132                                 for (i = 0; i < sg_used; i++) {
1133                                         if (copy_to_user
1134                                             (ptr, buff[i], buff_size[i])) {
1135                                                 cmd_free(host, c, 0);
1136                                                 status = -EFAULT;
1137                                                 goto cleanup1;
1138                                         }
1139                                         ptr += buff_size[i];
1140                                 }
1141                         }
1142                         cmd_free(host, c, 0);
1143                         status = 0;
1144                       cleanup1:
1145                         if (buff) {
1146                                 for (i = 0; i < sg_used; i++)
1147                                         kfree(buff[i]);
1148                                 kfree(buff);
1149                         }
1150                         kfree(buff_size);
1151                         kfree(ioc);
1152                         return status;
1153                 }
1154         default:
1155                 return -ENOTTY;
1156         }
1157 }
1158
1159 static inline void complete_buffers(struct bio *bio, int status)
1160 {
1161         while (bio) {
1162                 struct bio *xbh = bio->bi_next;
1163                 int nr_sectors = bio_sectors(bio);
1164
1165                 bio->bi_next = NULL;
1166                 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
1167                 bio = xbh;
1168         }
1169 }
1170
1171 static void cciss_check_queues(ctlr_info_t *h)
1172 {
1173         int start_queue = h->next_to_run;
1174         int i;
1175
1176         /* check to see if we have maxed out the number of commands that can
1177          * be placed on the queue.  If so then exit.  We do this check here
1178          * in case the interrupt we serviced was from an ioctl and did not
1179          * free any new commands.
1180          */
1181         if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)
1182                 return;
1183
1184         /* We have room on the queue for more commands.  Now we need to queue
1185          * them up.  We will also keep track of the next queue to run so
1186          * that every queue gets a chance to be started first.
1187          */
1188         for (i = 0; i < h->highest_lun + 1; i++) {
1189                 int curr_queue = (start_queue + i) % (h->highest_lun + 1);
1190                 /* make sure the disk has been added and the drive is real
1191                  * because this can be called from the middle of init_one.
1192                  */
1193                 if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
1194                         continue;
1195                 blk_start_queue(h->gendisk[curr_queue]->queue);
1196
1197                 /* check to see if we have maxed out the number of commands
1198                  * that can be placed on the queue.
1199                  */
1200                 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {
1201                         if (curr_queue == start_queue) {
1202                                 h->next_to_run =
1203                                     (start_queue + 1) % (h->highest_lun + 1);
1204                                 break;
1205                         } else {
1206                                 h->next_to_run = curr_queue;
1207                                 break;
1208                         }
1209                 } else {
1210                         curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
1211                 }
1212         }
1213 }
1214
1215 static void cciss_softirq_done(struct request *rq)
1216 {
1217         CommandList_struct *cmd = rq->completion_data;
1218         ctlr_info_t *h = hba[cmd->ctlr];
1219         unsigned long flags;
1220         u64bit temp64;
1221         int i, ddir;
1222
1223         if (cmd->Request.Type.Direction == XFER_READ)
1224                 ddir = PCI_DMA_FROMDEVICE;
1225         else
1226                 ddir = PCI_DMA_TODEVICE;
1227
1228         /* command did not need to be retried */
1229         /* unmap the DMA mapping for all the scatter gather elements */
1230         for (i = 0; i < cmd->Header.SGList; i++) {
1231                 temp64.val32.lower = cmd->SG[i].Addr.lower;
1232                 temp64.val32.upper = cmd->SG[i].Addr.upper;
1233                 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1234         }
1235
1236         complete_buffers(rq->bio, rq->errors);
1237
1238         if (blk_fs_request(rq)) {
1239                 const int rw = rq_data_dir(rq);
1240
1241                 disk_stat_add(rq->rq_disk, sectors[rw], rq->nr_sectors);
1242         }
1243
1244 #ifdef CCISS_DEBUG
1245         printk("Done with %p\n", rq);
1246 #endif                          /* CCISS_DEBUG */
1247
1248         add_disk_randomness(rq->rq_disk);
1249         spin_lock_irqsave(&h->lock, flags);
1250         end_that_request_last(rq, rq->errors);
1251         cmd_free(h, cmd, 1);
1252         cciss_check_queues(h);
1253         spin_unlock_irqrestore(&h->lock, flags);
1254 }
1255
1256 /* This function will check the usage_count of the drive to be updated/added.
1257  * If the usage_count is zero then the drive information will be updated and
1258  * the disk will be re-registered with the kernel.  If not then it will be
1259  * left alone for the next reboot.  The exception to this is disk 0 which
1260  * will always be left registered with the kernel since it is also the
1261  * controller node.  Any changes to disk 0 will show up on the next
1262  * reboot.
1263  */
1264 static void cciss_update_drive_info(int ctlr, int drv_index)
1265 {
1266         ctlr_info_t *h = hba[ctlr];
1267         struct gendisk *disk;
1268         InquiryData_struct *inq_buff = NULL;
1269         unsigned int block_size;
1270         sector_t total_size;
1271         unsigned long flags = 0;
1272         int ret = 0;
1273
1274         /* if the disk already exists then deregister it before proceeding */
1275         if (h->drv[drv_index].raid_level != -1) {
1276                 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1277                 h->drv[drv_index].busy_configuring = 1;
1278                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1279                 ret = deregister_disk(h->gendisk[drv_index],
1280                                       &h->drv[drv_index], 0);
1281                 h->drv[drv_index].busy_configuring = 0;
1282         }
1283
1284         /* If the disk is in use return */
1285         if (ret)
1286                 return;
1287
1288         /* Get information about the disk and modify the driver structure */
1289         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
1290         if (inq_buff == NULL)
1291                 goto mem_msg;
1292
1293         cciss_read_capacity(ctlr, drv_index, 1,
1294                             &total_size, &block_size);
1295
1296         /* total size = last LBA + 1 */
1297         /* FFFFFFFF + 1 = 0, cannot have a logical volume of size 0 */
1298         /* so we assume this volume this must be >2TB in size */
1299         if (total_size == (__u32) 0) {
1300                 cciss_read_capacity_16(ctlr, drv_index, 1,
1301                 &total_size, &block_size);
1302                 h->cciss_read = CCISS_READ_16;
1303                 h->cciss_write = CCISS_WRITE_16;
1304         } else {
1305                 h->cciss_read = CCISS_READ_10;
1306                 h->cciss_write = CCISS_WRITE_10;
1307         }
1308         cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1309                                inq_buff, &h->drv[drv_index]);
1310
1311         ++h->num_luns;
1312         disk = h->gendisk[drv_index];
1313         set_capacity(disk, h->drv[drv_index].nr_blocks);
1314
1315         /* if it's the controller it's already added */
1316         if (drv_index) {
1317                 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1318
1319                 /* Set up queue information */
1320                 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1321                 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1322
1323                 /* This is a hardware imposed limit. */
1324                 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1325
1326                 /* This is a limit in the driver and could be eliminated. */
1327                 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1328
1329                 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
1330
1331                 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1332
1333                 disk->queue->queuedata = hba[ctlr];
1334
1335                 blk_queue_hardsect_size(disk->queue,
1336                                         hba[ctlr]->drv[drv_index].block_size);
1337
1338                 h->drv[drv_index].queue = disk->queue;
1339                 add_disk(disk);
1340         }
1341
1342       freeret:
1343         kfree(inq_buff);
1344         return;
1345       mem_msg:
1346         printk(KERN_ERR "cciss: out of memory\n");
1347         goto freeret;
1348 }
1349
1350 /* This function will find the first index of the controllers drive array
1351  * that has a -1 for the raid_level and will return that index.  This is
1352  * where new drives will be added.  If the index to be returned is greater
1353  * than the highest_lun index for the controller then highest_lun is set
1354  * to this new index.  If there are no available indexes then -1 is returned.
1355  */
1356 static int cciss_find_free_drive_index(int ctlr)
1357 {
1358         int i;
1359
1360         for (i = 0; i < CISS_MAX_LUN; i++) {
1361                 if (hba[ctlr]->drv[i].raid_level == -1) {
1362                         if (i > hba[ctlr]->highest_lun)
1363                                 hba[ctlr]->highest_lun = i;
1364                         return i;
1365                 }
1366         }
1367         return -1;
1368 }
1369
1370 /* This function will add and remove logical drives from the Logical
1371  * drive array of the controller and maintain persistency of ordering
1372  * so that mount points are preserved until the next reboot.  This allows
1373  * for the removal of logical drives in the middle of the drive array
1374  * without a re-ordering of those drives.
1375  * INPUT
1376  * h            = The controller to perform the operations on
1377  * del_disk     = The disk to remove if specified.  If the value given
1378  *                is NULL then no disk is removed.
1379  */
1380 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1381 {
1382         int ctlr = h->ctlr;
1383         int num_luns;
1384         ReportLunData_struct *ld_buff = NULL;
1385         drive_info_struct *drv = NULL;
1386         int return_code;
1387         int listlength = 0;
1388         int i;
1389         int drv_found;
1390         int drv_index = 0;
1391         __u32 lunid = 0;
1392         unsigned long flags;
1393
1394         /* Set busy_configuring flag for this operation */
1395         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1396         if (h->num_luns >= CISS_MAX_LUN) {
1397                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1398                 return -EINVAL;
1399         }
1400
1401         if (h->busy_configuring) {
1402                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1403                 return -EBUSY;
1404         }
1405         h->busy_configuring = 1;
1406
1407         /* if del_disk is NULL then we are being called to add a new disk
1408          * and update the logical drive table.  If it is not NULL then
1409          * we will check if the disk is in use or not.
1410          */
1411         if (del_disk != NULL) {
1412                 drv = get_drv(del_disk);
1413                 drv->busy_configuring = 1;
1414                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1415                 return_code = deregister_disk(del_disk, drv, 1);
1416                 drv->busy_configuring = 0;
1417                 h->busy_configuring = 0;
1418                 return return_code;
1419         } else {
1420                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1421                 if (!capable(CAP_SYS_RAWIO))
1422                         return -EPERM;
1423
1424                 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1425                 if (ld_buff == NULL)
1426                         goto mem_msg;
1427
1428                 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1429                                               sizeof(ReportLunData_struct), 0,
1430                                               0, 0, TYPE_CMD);
1431
1432                 if (return_code == IO_OK) {
1433                         listlength |=
1434                             (0xff & (unsigned int)(ld_buff->LUNListLength[0]))
1435                             << 24;
1436                         listlength |=
1437                             (0xff & (unsigned int)(ld_buff->LUNListLength[1]))
1438                             << 16;
1439                         listlength |=
1440                             (0xff & (unsigned int)(ld_buff->LUNListLength[2]))
1441                             << 8;
1442                         listlength |=
1443                             0xff & (unsigned int)(ld_buff->LUNListLength[3]);
1444                 } else {        /* reading number of logical volumes failed */
1445                         printk(KERN_WARNING "cciss: report logical volume"
1446                                " command failed\n");
1447                         listlength = 0;
1448                         goto freeret;
1449                 }
1450
1451                 num_luns = listlength / 8;      /* 8 bytes per entry */
1452                 if (num_luns > CISS_MAX_LUN) {
1453                         num_luns = CISS_MAX_LUN;
1454                         printk(KERN_WARNING "cciss: more luns configured"
1455                                " on controller than can be handled by"
1456                                " this driver.\n");
1457                 }
1458
1459                 /* Compare controller drive array to drivers drive array.
1460                  * Check for updates in the drive information and any new drives
1461                  * on the controller.
1462                  */
1463                 for (i = 0; i < num_luns; i++) {
1464                         int j;
1465
1466                         drv_found = 0;
1467
1468                         lunid = (0xff &
1469                                  (unsigned int)(ld_buff->LUN[i][3])) << 24;
1470                         lunid |= (0xff &
1471                                   (unsigned int)(ld_buff->LUN[i][2])) << 16;
1472                         lunid |= (0xff &
1473                                   (unsigned int)(ld_buff->LUN[i][1])) << 8;
1474                         lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
1475
1476                         /* Find if the LUN is already in the drive array
1477                          * of the controller.  If so then update its info
1478                          * if not is use.  If it does not exist then find
1479                          * the first free index and add it.
1480                          */
1481                         for (j = 0; j <= h->highest_lun; j++) {
1482                                 if (h->drv[j].LunID == lunid) {
1483                                         drv_index = j;
1484                                         drv_found = 1;
1485                                 }
1486                         }
1487
1488                         /* check if the drive was found already in the array */
1489                         if (!drv_found) {
1490                                 drv_index = cciss_find_free_drive_index(ctlr);
1491                                 if (drv_index == -1)
1492                                         goto freeret;
1493
1494                         }
1495                         h->drv[drv_index].LunID = lunid;
1496                         cciss_update_drive_info(ctlr, drv_index);
1497                 }               /* end for */
1498         }                       /* end else */
1499
1500       freeret:
1501         kfree(ld_buff);
1502         h->busy_configuring = 0;
1503         /* We return -1 here to tell the ACU that we have registered/updated
1504          * all of the drives that we can and to keep it from calling us
1505          * additional times.
1506          */
1507         return -1;
1508       mem_msg:
1509         printk(KERN_ERR "cciss: out of memory\n");
1510         goto freeret;
1511 }
1512
1513 /* This function will deregister the disk and it's queue from the
1514  * kernel.  It must be called with the controller lock held and the
1515  * drv structures busy_configuring flag set.  It's parameters are:
1516  *
1517  * disk = This is the disk to be deregistered
1518  * drv  = This is the drive_info_struct associated with the disk to be
1519  *        deregistered.  It contains information about the disk used
1520  *        by the driver.
1521  * clear_all = This flag determines whether or not the disk information
1522  *             is going to be completely cleared out and the highest_lun
1523  *             reset.  Sometimes we want to clear out information about
1524  *             the disk in preparation for re-adding it.  In this case
1525  *             the highest_lun should be left unchanged and the LunID
1526  *             should not be cleared.
1527 */
1528 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1529                            int clear_all)
1530 {
1531         ctlr_info_t *h = get_host(disk);
1532
1533         if (!capable(CAP_SYS_RAWIO))
1534                 return -EPERM;
1535
1536         /* make sure logical volume is NOT is use */
1537         if (clear_all || (h->gendisk[0] == disk)) {
1538                 if (drv->usage_count > 1)
1539                         return -EBUSY;
1540         } else if (drv->usage_count > 0)
1541                 return -EBUSY;
1542
1543         /* invalidate the devices and deregister the disk.  If it is disk
1544          * zero do not deregister it but just zero out it's values.  This
1545          * allows us to delete disk zero but keep the controller registered.
1546          */
1547         if (h->gendisk[0] != disk) {
1548                 if (disk) {
1549                         request_queue_t *q = disk->queue;
1550                         if (disk->flags & GENHD_FL_UP)
1551                                 del_gendisk(disk);
1552                         if (q) {
1553                                 blk_cleanup_queue(q);
1554                                 drv->queue = NULL;
1555                         }
1556                 }
1557         }
1558
1559         --h->num_luns;
1560         /* zero out the disk size info */
1561         drv->nr_blocks = 0;
1562         drv->block_size = 0;
1563         drv->heads = 0;
1564         drv->sectors = 0;
1565         drv->cylinders = 0;
1566         drv->raid_level = -1;   /* This can be used as a flag variable to
1567                                  * indicate that this element of the drive
1568                                  * array is free.
1569                                  */
1570
1571         if (clear_all) {
1572                 /* check to see if it was the last disk */
1573                 if (drv == h->drv + h->highest_lun) {
1574                         /* if so, find the new hightest lun */
1575                         int i, newhighest = -1;
1576                         for (i = 0; i < h->highest_lun; i++) {
1577                                 /* if the disk has size > 0, it is available */
1578                                 if (h->drv[i].heads)
1579                                         newhighest = i;
1580                         }
1581                         h->highest_lun = newhighest;
1582                 }
1583
1584                 drv->LunID = 0;
1585         }
1586         return 0;
1587 }
1588
1589 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
1590                                                                                                                            1: address logical volume log_unit,
1591                                                                                                                            2: periph device address is scsi3addr */
1592                     unsigned int log_unit, __u8 page_code,
1593                     unsigned char *scsi3addr, int cmd_type)
1594 {
1595         ctlr_info_t *h = hba[ctlr];
1596         u64bit buff_dma_handle;
1597         int status = IO_OK;
1598
1599         c->cmd_type = CMD_IOCTL_PEND;
1600         c->Header.ReplyQueue = 0;
1601         if (buff != NULL) {
1602                 c->Header.SGList = 1;
1603                 c->Header.SGTotal = 1;
1604         } else {
1605                 c->Header.SGList = 0;
1606                 c->Header.SGTotal = 0;
1607         }
1608         c->Header.Tag.lower = c->busaddr;
1609
1610         c->Request.Type.Type = cmd_type;
1611         if (cmd_type == TYPE_CMD) {
1612                 switch (cmd) {
1613                 case CISS_INQUIRY:
1614                         /* If the logical unit number is 0 then, this is going
1615                            to controller so It's a physical command
1616                            mode = 0 target = 0.  So we have nothing to write.
1617                            otherwise, if use_unit_num == 1,
1618                            mode = 1(volume set addressing) target = LUNID
1619                            otherwise, if use_unit_num == 2,
1620                            mode = 0(periph dev addr) target = scsi3addr */
1621                         if (use_unit_num == 1) {
1622                                 c->Header.LUN.LogDev.VolId =
1623                                     h->drv[log_unit].LunID;
1624                                 c->Header.LUN.LogDev.Mode = 1;
1625                         } else if (use_unit_num == 2) {
1626                                 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1627                                        8);
1628                                 c->Header.LUN.LogDev.Mode = 0;
1629                         }
1630                         /* are we trying to read a vital product page */
1631                         if (page_code != 0) {
1632                                 c->Request.CDB[1] = 0x01;
1633                                 c->Request.CDB[2] = page_code;
1634                         }
1635                         c->Request.CDBLen = 6;
1636                         c->Request.Type.Attribute = ATTR_SIMPLE;
1637                         c->Request.Type.Direction = XFER_READ;
1638                         c->Request.Timeout = 0;
1639                         c->Request.CDB[0] = CISS_INQUIRY;
1640                         c->Request.CDB[4] = size & 0xFF;
1641                         break;
1642                 case CISS_REPORT_LOG:
1643                 case CISS_REPORT_PHYS:
1644                         /* Talking to controller so It's a physical command
1645                            mode = 00 target = 0.  Nothing to write.
1646                          */
1647                         c->Request.CDBLen = 12;
1648                         c->Request.Type.Attribute = ATTR_SIMPLE;
1649                         c->Request.Type.Direction = XFER_READ;
1650                         c->Request.Timeout = 0;
1651                         c->Request.CDB[0] = cmd;
1652                         c->Request.CDB[6] = (size >> 24) & 0xFF;        //MSB
1653                         c->Request.CDB[7] = (size >> 16) & 0xFF;
1654                         c->Request.CDB[8] = (size >> 8) & 0xFF;
1655                         c->Request.CDB[9] = size & 0xFF;
1656                         break;
1657
1658                 case CCISS_READ_CAPACITY:
1659                         c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1660                         c->Header.LUN.LogDev.Mode = 1;
1661                         c->Request.CDBLen = 10;
1662                         c->Request.Type.Attribute = ATTR_SIMPLE;
1663                         c->Request.Type.Direction = XFER_READ;
1664                         c->Request.Timeout = 0;
1665                         c->Request.CDB[0] = cmd;
1666                         break;
1667                 case CCISS_READ_CAPACITY_16:
1668                         c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1669                         c->Header.LUN.LogDev.Mode = 1;
1670                         c->Request.CDBLen = 16;
1671                         c->Request.Type.Attribute = ATTR_SIMPLE;
1672                         c->Request.Type.Direction = XFER_READ;
1673                         c->Request.Timeout = 0;
1674                         c->Request.CDB[0] = cmd;
1675                         c->Request.CDB[1] = 0x10;
1676                         c->Request.CDB[10] = (size >> 24) & 0xFF;
1677                         c->Request.CDB[11] = (size >> 16) & 0xFF;
1678                         c->Request.CDB[12] = (size >> 8) & 0xFF;
1679                         c->Request.CDB[13] = size & 0xFF;
1680                         c->Request.Timeout = 0;
1681                         c->Request.CDB[0] = cmd;
1682                         break;
1683                 case CCISS_CACHE_FLUSH:
1684                         c->Request.CDBLen = 12;
1685                         c->Request.Type.Attribute = ATTR_SIMPLE;
1686                         c->Request.Type.Direction = XFER_WRITE;
1687                         c->Request.Timeout = 0;
1688                         c->Request.CDB[0] = BMIC_WRITE;
1689                         c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1690                         break;
1691                 default:
1692                         printk(KERN_WARNING
1693                                "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
1694                         return IO_ERROR;
1695                 }
1696         } else if (cmd_type == TYPE_MSG) {
1697                 switch (cmd) {
1698                 case 0: /* ABORT message */
1699                         c->Request.CDBLen = 12;
1700                         c->Request.Type.Attribute = ATTR_SIMPLE;
1701                         c->Request.Type.Direction = XFER_WRITE;
1702                         c->Request.Timeout = 0;
1703                         c->Request.CDB[0] = cmd;        /* abort */
1704                         c->Request.CDB[1] = 0;  /* abort a command */
1705                         /* buff contains the tag of the command to abort */
1706                         memcpy(&c->Request.CDB[4], buff, 8);
1707                         break;
1708                 case 1: /* RESET message */
1709                         c->Request.CDBLen = 12;
1710                         c->Request.Type.Attribute = ATTR_SIMPLE;
1711                         c->Request.Type.Direction = XFER_WRITE;
1712                         c->Request.Timeout = 0;
1713                         memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1714                         c->Request.CDB[0] = cmd;        /* reset */
1715                         c->Request.CDB[1] = 0x04;       /* reset a LUN */
1716                         break;
1717                 case 3: /* No-Op message */
1718                         c->Request.CDBLen = 1;
1719                         c->Request.Type.Attribute = ATTR_SIMPLE;
1720                         c->Request.Type.Direction = XFER_WRITE;
1721                         c->Request.Timeout = 0;
1722                         c->Request.CDB[0] = cmd;
1723                         break;
1724                 default:
1725                         printk(KERN_WARNING
1726                                "cciss%d: unknown message type %d\n", ctlr, cmd);
1727                         return IO_ERROR;
1728                 }
1729         } else {
1730                 printk(KERN_WARNING
1731                        "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1732                 return IO_ERROR;
1733         }
1734         /* Fill in the scatter gather information */
1735         if (size > 0) {
1736                 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1737                                                              buff, size,
1738                                                              PCI_DMA_BIDIRECTIONAL);
1739                 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1740                 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1741                 c->SG[0].Len = size;
1742                 c->SG[0].Ext = 0;       /* we are not chaining */
1743         }
1744         return status;
1745 }
1746
1747 static int sendcmd_withirq(__u8 cmd,
1748                            int ctlr,
1749                            void *buff,
1750                            size_t size,
1751                            unsigned int use_unit_num,
1752                            unsigned int log_unit, __u8 page_code, int cmd_type)
1753 {
1754         ctlr_info_t *h = hba[ctlr];
1755         CommandList_struct *c;
1756         u64bit buff_dma_handle;
1757         unsigned long flags;
1758         int return_status;
1759         DECLARE_COMPLETION_ONSTACK(wait);
1760
1761         if ((c = cmd_alloc(h, 0)) == NULL)
1762                 return -ENOMEM;
1763         return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1764                                  log_unit, page_code, NULL, cmd_type);
1765         if (return_status != IO_OK) {
1766                 cmd_free(h, c, 0);
1767                 return return_status;
1768         }
1769       resend_cmd2:
1770         c->waiting = &wait;
1771
1772         /* Put the request on the tail of the queue and send it */
1773         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1774         addQ(&h->reqQ, c);
1775         h->Qdepth++;
1776         start_io(h);
1777         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1778
1779         wait_for_completion(&wait);
1780
1781         if (c->err_info->CommandStatus != 0) {  /* an error has occurred */
1782                 switch (c->err_info->CommandStatus) {
1783                 case CMD_TARGET_STATUS:
1784                         printk(KERN_WARNING "cciss: cmd %p has "
1785                                " completed with errors\n", c);
1786                         if (c->err_info->ScsiStatus) {
1787                                 printk(KERN_WARNING "cciss: cmd %p "
1788                                        "has SCSI Status = %x\n",
1789                                        c, c->err_info->ScsiStatus);
1790                         }
1791
1792                         break;
1793                 case CMD_DATA_UNDERRUN:
1794                 case CMD_DATA_OVERRUN:
1795                         /* expected for inquire and report lun commands */
1796                         break;
1797                 case CMD_INVALID:
1798                         printk(KERN_WARNING "cciss: Cmd %p is "
1799                                "reported invalid\n", c);
1800                         return_status = IO_ERROR;
1801                         break;
1802                 case CMD_PROTOCOL_ERR:
1803                         printk(KERN_WARNING "cciss: cmd %p has "
1804                                "protocol error \n", c);
1805                         return_status = IO_ERROR;
1806                         break;
1807                 case CMD_HARDWARE_ERR:
1808                         printk(KERN_WARNING "cciss: cmd %p had "
1809                                " hardware error\n", c);
1810                         return_status = IO_ERROR;
1811                         break;
1812                 case CMD_CONNECTION_LOST:
1813                         printk(KERN_WARNING "cciss: cmd %p had "
1814                                "connection lost\n", c);
1815                         return_status = IO_ERROR;
1816                         break;
1817                 case CMD_ABORTED:
1818                         printk(KERN_WARNING "cciss: cmd %p was "
1819                                "aborted\n", c);
1820                         return_status = IO_ERROR;
1821                         break;
1822                 case CMD_ABORT_FAILED:
1823                         printk(KERN_WARNING "cciss: cmd %p reports "
1824                                "abort failed\n", c);
1825                         return_status = IO_ERROR;
1826                         break;
1827                 case CMD_UNSOLICITED_ABORT:
1828                         printk(KERN_WARNING
1829                                "cciss%d: unsolicited abort %p\n", ctlr, c);
1830                         if (c->retry_count < MAX_CMD_RETRIES) {
1831                                 printk(KERN_WARNING
1832                                        "cciss%d: retrying %p\n", ctlr, c);
1833                                 c->retry_count++;
1834                                 /* erase the old error information */
1835                                 memset(c->err_info, 0,
1836                                        sizeof(ErrorInfo_struct));
1837                                 return_status = IO_OK;
1838                                 INIT_COMPLETION(wait);
1839                                 goto resend_cmd2;
1840                         }
1841                         return_status = IO_ERROR;
1842                         break;
1843                 default:
1844                         printk(KERN_WARNING "cciss: cmd %p returned "
1845                                "unknown status %x\n", c,
1846                                c->err_info->CommandStatus);
1847                         return_status = IO_ERROR;
1848                 }
1849         }
1850         /* unlock the buffers from DMA */
1851         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1852         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1853         pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
1854                          c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1855         cmd_free(h, c, 0);
1856         return return_status;
1857 }
1858
1859 static void cciss_geometry_inquiry(int ctlr, int logvol,
1860                                    int withirq, sector_t total_size,
1861                                    unsigned int block_size,
1862                                    InquiryData_struct *inq_buff,
1863                                    drive_info_struct *drv)
1864 {
1865         int return_code;
1866         unsigned long t;
1867
1868         memset(inq_buff, 0, sizeof(InquiryData_struct));
1869         if (withirq)
1870                 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1871                                               inq_buff, sizeof(*inq_buff), 1,
1872                                               logvol, 0xC1, TYPE_CMD);
1873         else
1874                 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1875                                       sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
1876                                       TYPE_CMD);
1877         if (return_code == IO_OK) {
1878                 if (inq_buff->data_byte[8] == 0xFF) {
1879                         printk(KERN_WARNING
1880                                "cciss: reading geometry failed, volume "
1881                                "does not support reading geometry\n");
1882                         drv->heads = 255;
1883                         drv->sectors = 32;      // Sectors per track
1884                 } else {
1885                         drv->heads = inq_buff->data_byte[6];
1886                         drv->sectors = inq_buff->data_byte[7];
1887                         drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1888                         drv->cylinders += inq_buff->data_byte[5];
1889                         drv->raid_level = inq_buff->data_byte[8];
1890                 }
1891                 drv->block_size = block_size;
1892                 drv->nr_blocks = total_size;
1893                 t = drv->heads * drv->sectors;
1894                 if (t > 1) {
1895                         unsigned rem = sector_div(total_size, t);
1896                         if (rem)
1897                                 total_size++;
1898                         drv->cylinders = total_size;
1899                 }
1900         } else {                /* Get geometry failed */
1901                 printk(KERN_WARNING "cciss: reading geometry failed\n");
1902         }
1903         printk(KERN_INFO "      heads=%d, sectors=%d, cylinders=%d\n\n",
1904                drv->heads, drv->sectors, drv->cylinders);
1905 }
1906
1907 static void
1908 cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
1909                     unsigned int *block_size)
1910 {
1911         ReadCapdata_struct *buf;
1912         int return_code;
1913         buf = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
1914         if (buf == NULL) {
1915                 printk(KERN_WARNING "cciss: out of memory\n");
1916                 return;
1917         }
1918         memset(buf, 0, sizeof(ReadCapdata_struct));
1919         if (withirq)
1920                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1921                                 ctlr, buf, sizeof(ReadCapdata_struct),
1922                                         1, logvol, 0, TYPE_CMD);
1923         else
1924                 return_code = sendcmd(CCISS_READ_CAPACITY,
1925                                 ctlr, buf, sizeof(ReadCapdata_struct),
1926                                         1, logvol, 0, NULL, TYPE_CMD);
1927         if (return_code == IO_OK) {
1928                 *total_size = be32_to_cpu(*(__u32 *) buf->total_size)+1;
1929                 *block_size = be32_to_cpu(*(__u32 *) buf->block_size);
1930         } else {                /* read capacity command failed */
1931                 printk(KERN_WARNING "cciss: read capacity failed\n");
1932                 *total_size = 0;
1933                 *block_size = BLOCK_SIZE;
1934         }
1935         if (*total_size != (__u32) 0)
1936                 printk(KERN_INFO "      blocks= %llu block_size= %d\n",
1937                 (unsigned long long)*total_size, *block_size);
1938         kfree(buf);
1939         return;
1940 }
1941
1942 static void
1943 cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,                                 unsigned int *block_size)
1944 {
1945         ReadCapdata_struct_16 *buf;
1946         int return_code;
1947         buf = kmalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
1948         if (buf == NULL) {
1949                 printk(KERN_WARNING "cciss: out of memory\n");
1950                 return;
1951         }
1952         memset(buf, 0, sizeof(ReadCapdata_struct_16));
1953         if (withirq) {
1954                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
1955                         ctlr, buf, sizeof(ReadCapdata_struct_16),
1956                                 1, logvol, 0, TYPE_CMD);
1957         }
1958         else {
1959                 return_code = sendcmd(CCISS_READ_CAPACITY_16,
1960                         ctlr, buf, sizeof(ReadCapdata_struct_16),
1961                                 1, logvol, 0, NULL, TYPE_CMD);
1962         }
1963         if (return_code == IO_OK) {
1964                 *total_size = be64_to_cpu(*(__u64 *) buf->total_size)+1;
1965                 *block_size = be32_to_cpu(*(__u32 *) buf->block_size);
1966         } else {                /* read capacity command failed */
1967                 printk(KERN_WARNING "cciss: read capacity failed\n");
1968                 *total_size = 0;
1969                 *block_size = BLOCK_SIZE;
1970         }
1971         printk(KERN_INFO "      blocks= %llu block_size= %d\n",
1972                (unsigned long long)*total_size, *block_size);
1973         kfree(buf);
1974         return;
1975 }
1976
1977 static int cciss_revalidate(struct gendisk *disk)
1978 {
1979         ctlr_info_t *h = get_host(disk);
1980         drive_info_struct *drv = get_drv(disk);
1981         int logvol;
1982         int FOUND = 0;
1983         unsigned int block_size;
1984         sector_t total_size;
1985         InquiryData_struct *inq_buff = NULL;
1986
1987         for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
1988                 if (h->drv[logvol].LunID == drv->LunID) {
1989                         FOUND = 1;
1990                         break;
1991                 }
1992         }
1993
1994         if (!FOUND)
1995                 return 1;
1996
1997         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
1998         if (inq_buff == NULL) {
1999                 printk(KERN_WARNING "cciss: out of memory\n");
2000                 return 1;
2001         }
2002         if (h->cciss_read == CCISS_READ_10) {
2003                 cciss_read_capacity(h->ctlr, logvol, 1,
2004                                         &total_size, &block_size);
2005         } else {
2006                 cciss_read_capacity_16(h->ctlr, logvol, 1,
2007                                         &total_size, &block_size);
2008         }
2009         cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2010                                inq_buff, drv);
2011
2012         blk_queue_hardsect_size(drv->queue, drv->block_size);
2013         set_capacity(disk, drv->nr_blocks);
2014
2015         kfree(inq_buff);
2016         return 0;
2017 }
2018
2019 /*
2020  *   Wait polling for a command to complete.
2021  *   The memory mapped FIFO is polled for the completion.
2022  *   Used only at init time, interrupts from the HBA are disabled.
2023  */
2024 static unsigned long pollcomplete(int ctlr)
2025 {
2026         unsigned long done;
2027         int i;
2028
2029         /* Wait (up to 20 seconds) for a command to complete */
2030
2031         for (i = 20 * HZ; i > 0; i--) {
2032                 done = hba[ctlr]->access.command_completed(hba[ctlr]);
2033                 if (done == FIFO_EMPTY)
2034                         schedule_timeout_uninterruptible(1);
2035                 else
2036                         return done;
2037         }
2038         /* Invalid address to tell caller we ran out of time */
2039         return 1;
2040 }
2041
2042 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2043 {
2044         /* We get in here if sendcmd() is polling for completions
2045            and gets some command back that it wasn't expecting --
2046            something other than that which it just sent down.
2047            Ordinarily, that shouldn't happen, but it can happen when
2048            the scsi tape stuff gets into error handling mode, and
2049            starts using sendcmd() to try to abort commands and
2050            reset tape drives.  In that case, sendcmd may pick up
2051            completions of commands that were sent to logical drives
2052            through the block i/o system, or cciss ioctls completing, etc.
2053            In that case, we need to save those completions for later
2054            processing by the interrupt handler.
2055          */
2056
2057 #ifdef CONFIG_CISS_SCSI_TAPE
2058         struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
2059
2060         /* If it's not the scsi tape stuff doing error handling, (abort */
2061         /* or reset) then we don't expect anything weird. */
2062         if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2063 #endif
2064                 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2065                        "Invalid command list address returned! (%lx)\n",
2066                        ctlr, complete);
2067                 /* not much we can do. */
2068 #ifdef CONFIG_CISS_SCSI_TAPE
2069                 return 1;
2070         }
2071
2072         /* We've sent down an abort or reset, but something else
2073            has completed */
2074         if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
2075                 /* Uh oh.  No room to save it for later... */
2076                 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
2077                        "reject list overflow, command lost!\n", ctlr);
2078                 return 1;
2079         }
2080         /* Save it for later */
2081         srl->complete[srl->ncompletions] = complete;
2082         srl->ncompletions++;
2083 #endif
2084         return 0;
2085 }
2086
2087 /*
2088  * Send a command to the controller, and wait for it to complete.
2089  * Only used at init time.
2090  */
2091 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
2092                                                                                                    1: address logical volume log_unit,
2093                                                                                                    2: periph device address is scsi3addr */
2094                    unsigned int log_unit,
2095                    __u8 page_code, unsigned char *scsi3addr, int cmd_type)
2096 {
2097         CommandList_struct *c;
2098         int i;
2099         unsigned long complete;
2100         ctlr_info_t *info_p = hba[ctlr];
2101         u64bit buff_dma_handle;
2102         int status, done = 0;
2103
2104         if ((c = cmd_alloc(info_p, 1)) == NULL) {
2105                 printk(KERN_WARNING "cciss: unable to get memory");
2106                 return IO_ERROR;
2107         }
2108         status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2109                           log_unit, page_code, scsi3addr, cmd_type);
2110         if (status != IO_OK) {
2111                 cmd_free(info_p, c, 1);
2112                 return status;
2113         }
2114       resend_cmd1:
2115         /*
2116          * Disable interrupt
2117          */
2118 #ifdef CCISS_DEBUG
2119         printk(KERN_DEBUG "cciss: turning intr off\n");
2120 #endif                          /* CCISS_DEBUG */
2121         info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2122
2123         /* Make sure there is room in the command FIFO */
2124         /* Actually it should be completely empty at this time */
2125         /* unless we are in here doing error handling for the scsi */
2126         /* tape side of the driver. */
2127         for (i = 200000; i > 0; i--) {
2128                 /* if fifo isn't full go */
2129                 if (!(info_p->access.fifo_full(info_p))) {
2130
2131                         break;
2132                 }
2133                 udelay(10);
2134                 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2135                        " waiting!\n", ctlr);
2136         }
2137         /*
2138          * Send the cmd
2139          */
2140         info_p->access.submit_command(info_p, c);
2141         done = 0;
2142         do {
2143                 complete = pollcomplete(ctlr);
2144
2145 #ifdef CCISS_DEBUG
2146                 printk(KERN_DEBUG "cciss: command completed\n");
2147 #endif                          /* CCISS_DEBUG */
2148
2149                 if (complete == 1) {
2150                         printk(KERN_WARNING
2151                                "cciss cciss%d: SendCmd Timeout out, "
2152                                "No command list address returned!\n", ctlr);
2153                         status = IO_ERROR;
2154                         done = 1;
2155                         break;
2156                 }
2157
2158                 /* This will need to change for direct lookup completions */
2159                 if ((complete & CISS_ERROR_BIT)
2160                     && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2161                         /* if data overrun or underun on Report command
2162                            ignore it
2163                          */
2164                         if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2165                              (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2166                              (c->Request.CDB[0] == CISS_INQUIRY)) &&
2167                             ((c->err_info->CommandStatus ==
2168                               CMD_DATA_OVERRUN) ||
2169                              (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2170                             )) {
2171                                 complete = c->busaddr;
2172                         } else {
2173                                 if (c->err_info->CommandStatus ==
2174                                     CMD_UNSOLICITED_ABORT) {
2175                                         printk(KERN_WARNING "cciss%d: "
2176                                                "unsolicited abort %p\n",
2177                                                ctlr, c);
2178                                         if (c->retry_count < MAX_CMD_RETRIES) {
2179                                                 printk(KERN_WARNING
2180                                                        "cciss%d: retrying %p\n",
2181                                                        ctlr, c);
2182                                                 c->retry_count++;
2183                                                 /* erase the old error */
2184                                                 /* information */
2185                                                 memset(c->err_info, 0,
2186                                                        sizeof
2187                                                        (ErrorInfo_struct));
2188                                                 goto resend_cmd1;
2189                                         } else {
2190                                                 printk(KERN_WARNING
2191                                                        "cciss%d: retried %p too "
2192                                                        "many times\n", ctlr, c);
2193                                                 status = IO_ERROR;
2194                                                 goto cleanup1;
2195                                         }
2196                                 } else if (c->err_info->CommandStatus ==
2197                                            CMD_UNABORTABLE) {
2198                                         printk(KERN_WARNING
2199                                                "cciss%d: command could not be aborted.\n",
2200                                                ctlr);
2201                                         status = IO_ERROR;
2202                                         goto cleanup1;
2203                                 }
2204                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2205                                        " Error %x \n", ctlr,
2206                                        c->err_info->CommandStatus);
2207                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2208                                        " offensive info\n"
2209                                        "  size %x\n   num %x   value %x\n",
2210                                        ctlr,
2211                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2212                                        offense_size,
2213                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2214                                        offense_num,
2215                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2216                                        offense_value);
2217                                 status = IO_ERROR;
2218                                 goto cleanup1;
2219                         }
2220                 }
2221                 /* This will need changing for direct lookup completions */
2222                 if (complete != c->busaddr) {
2223                         if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2224                                 BUG();  /* we are pretty much hosed if we get here. */
2225                         }
2226                         continue;
2227                 } else
2228                         done = 1;
2229         } while (!done);
2230
2231       cleanup1:
2232         /* unlock the data buffer from DMA */
2233         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2234         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2235         pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2236                          c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2237 #ifdef CONFIG_CISS_SCSI_TAPE
2238         /* if we saved some commands for later, process them now. */
2239         if (info_p->scsi_rejects.ncompletions > 0)
2240                 do_cciss_intr(0, info_p);
2241 #endif
2242         cmd_free(info_p, c, 1);
2243         return status;
2244 }
2245
2246 /*
2247  * Map (physical) PCI mem into (virtual) kernel space
2248  */
2249 static void __iomem *remap_pci_mem(ulong base, ulong size)
2250 {
2251         ulong page_base = ((ulong) base) & PAGE_MASK;
2252         ulong page_offs = ((ulong) base) - page_base;
2253         void __iomem *page_remapped = ioremap(page_base, page_offs + size);
2254
2255         return page_remapped ? (page_remapped + page_offs) : NULL;
2256 }
2257
2258 /*
2259  * Takes jobs of the Q and sends them to the hardware, then puts it on
2260  * the Q to wait for completion.
2261  */
2262 static void start_io(ctlr_info_t *h)
2263 {
2264         CommandList_struct *c;
2265
2266         while ((c = h->reqQ) != NULL) {
2267                 /* can't do anything if fifo is full */
2268                 if ((h->access.fifo_full(h))) {
2269                         printk(KERN_WARNING "cciss: fifo full\n");
2270                         break;
2271                 }
2272
2273                 /* Get the first entry from the Request Q */
2274                 removeQ(&(h->reqQ), c);
2275                 h->Qdepth--;
2276
2277                 /* Tell the controller execute command */
2278                 h->access.submit_command(h, c);
2279
2280                 /* Put job onto the completed Q */
2281                 addQ(&(h->cmpQ), c);
2282         }
2283 }
2284
2285 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2286 /* Zeros out the error record and then resends the command back */
2287 /* to the controller */
2288 static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
2289 {
2290         /* erase the old error information */
2291         memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2292
2293         /* add it to software queue and then send it to the controller */
2294         addQ(&(h->reqQ), c);
2295         h->Qdepth++;
2296         if (h->Qdepth > h->maxQsinceinit)
2297                 h->maxQsinceinit = h->Qdepth;
2298
2299         start_io(h);
2300 }
2301
2302 /* checks the status of the job and calls complete buffers to mark all
2303  * buffers for the completed job. Note that this function does not need
2304  * to hold the hba/queue lock.
2305  */
2306 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2307                                     int timeout)
2308 {
2309         int status = 1;
2310         int retry_cmd = 0;
2311
2312         if (timeout)
2313                 status = 0;
2314
2315         if (cmd->err_info->CommandStatus != 0) {        /* an error has occurred */
2316                 switch (cmd->err_info->CommandStatus) {
2317                         unsigned char sense_key;
2318                 case CMD_TARGET_STATUS:
2319                         status = 0;
2320
2321                         if (cmd->err_info->ScsiStatus == 0x02) {
2322                                 printk(KERN_WARNING "cciss: cmd %p "
2323                                        "has CHECK CONDITION "
2324                                        " byte 2 = 0x%x\n", cmd,
2325                                        cmd->err_info->SenseInfo[2]
2326                                     );
2327                                 /* check the sense key */
2328                                 sense_key = 0xf & cmd->err_info->SenseInfo[2];
2329                                 /* no status or recovered error */
2330                                 if ((sense_key == 0x0) || (sense_key == 0x1)) {
2331                                         status = 1;
2332                                 }
2333                         } else {
2334                                 printk(KERN_WARNING "cciss: cmd %p "
2335                                        "has SCSI Status 0x%x\n",
2336                                        cmd, cmd->err_info->ScsiStatus);
2337                         }
2338                         break;
2339                 case CMD_DATA_UNDERRUN:
2340                         printk(KERN_WARNING "cciss: cmd %p has"
2341                                " completed with data underrun "
2342                                "reported\n", cmd);
2343                         break;
2344                 case CMD_DATA_OVERRUN:
2345                         printk(KERN_WARNING "cciss: cmd %p has"
2346                                " completed with data overrun "
2347                                "reported\n", cmd);
2348                         break;
2349                 case CMD_INVALID:
2350                         printk(KERN_WARNING "cciss: cmd %p is "
2351                                "reported invalid\n", cmd);
2352                         status = 0;
2353                         break;
2354                 case CMD_PROTOCOL_ERR:
2355                         printk(KERN_WARNING "cciss: cmd %p has "
2356                                "protocol error \n", cmd);
2357                         status = 0;
2358                         break;
2359                 case CMD_HARDWARE_ERR:
2360                         printk(KERN_WARNING "cciss: cmd %p had "
2361                                " hardware error\n", cmd);
2362                         status = 0;
2363                         break;
2364                 case CMD_CONNECTION_LOST:
2365                         printk(KERN_WARNING "cciss: cmd %p had "
2366                                "connection lost\n", cmd);
2367                         status = 0;
2368                         break;
2369                 case CMD_ABORTED:
2370                         printk(KERN_WARNING "cciss: cmd %p was "
2371                                "aborted\n", cmd);
2372                         status = 0;
2373                         break;
2374                 case CMD_ABORT_FAILED:
2375                         printk(KERN_WARNING "cciss: cmd %p reports "
2376                                "abort failed\n", cmd);
2377                         status = 0;
2378                         break;
2379                 case CMD_UNSOLICITED_ABORT:
2380                         printk(KERN_WARNING "cciss%d: unsolicited "
2381                                "abort %p\n", h->ctlr, cmd);
2382                         if (cmd->retry_count < MAX_CMD_RETRIES) {
2383                                 retry_cmd = 1;
2384                                 printk(KERN_WARNING
2385                                        "cciss%d: retrying %p\n", h->ctlr, cmd);
2386                                 cmd->retry_count++;
2387                         } else
2388                                 printk(KERN_WARNING
2389                                        "cciss%d: %p retried too "
2390                                        "many times\n", h->ctlr, cmd);
2391                         status = 0;
2392                         break;
2393                 case CMD_TIMEOUT:
2394                         printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2395                         status = 0;
2396                         break;
2397                 default:
2398                         printk(KERN_WARNING "cciss: cmd %p returned "
2399                                "unknown status %x\n", cmd,
2400                                cmd->err_info->CommandStatus);
2401                         status = 0;
2402                 }
2403         }
2404         /* We need to return this command */
2405         if (retry_cmd) {
2406                 resend_cciss_cmd(h, cmd);
2407                 return;
2408         }
2409
2410         cmd->rq->completion_data = cmd;
2411         cmd->rq->errors = status;
2412         blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
2413         blk_complete_request(cmd->rq);
2414 }
2415
2416 /*
2417  * Get a request and submit it to the controller.
2418  */
2419 static void do_cciss_request(request_queue_t *q)
2420 {
2421         ctlr_info_t *h = q->queuedata;
2422         CommandList_struct *c;
2423         sector_t start_blk;
2424         int seg;
2425         struct request *creq;
2426         u64bit temp64;
2427         struct scatterlist tmp_sg[MAXSGENTRIES];
2428         drive_info_struct *drv;
2429         int i, dir;
2430
2431         /* We call start_io here in case there is a command waiting on the
2432          * queue that has not been sent.
2433          */
2434         if (blk_queue_plugged(q))
2435                 goto startio;
2436
2437       queue:
2438         creq = elv_next_request(q);
2439         if (!creq)
2440                 goto startio;
2441
2442         BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2443
2444         if ((c = cmd_alloc(h, 1)) == NULL)
2445                 goto full;
2446
2447         blkdev_dequeue_request(creq);
2448
2449         spin_unlock_irq(q->queue_lock);
2450
2451         c->cmd_type = CMD_RWREQ;
2452         c->rq = creq;
2453
2454         /* fill in the request */
2455         drv = creq->rq_disk->private_data;
2456         c->Header.ReplyQueue = 0;       // unused in simple mode
2457         /* got command from pool, so use the command block index instead */
2458         /* for direct lookups. */
2459         /* The first 2 bits are reserved for controller error reporting. */
2460         c->Header.Tag.lower = (c->cmdindex << 3);
2461         c->Header.Tag.lower |= 0x04;    /* flag for direct lookup. */
2462         c->Header.LUN.LogDev.VolId = drv->LunID;
2463         c->Header.LUN.LogDev.Mode = 1;
2464         c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2465         c->Request.Type.Type = TYPE_CMD;        // It is a command.
2466         c->Request.Type.Attribute = ATTR_SIMPLE;
2467         c->Request.Type.Direction =
2468             (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2469         c->Request.Timeout = 0; // Don't time out
2470         c->Request.CDB[0] =
2471             (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2472         start_blk = creq->sector;
2473 #ifdef CCISS_DEBUG
2474         printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2475                (int)creq->nr_sectors);
2476 #endif                          /* CCISS_DEBUG */
2477
2478         seg = blk_rq_map_sg(q, creq, tmp_sg);
2479
2480         /* get the DMA records for the setup */
2481         if (c->Request.Type.Direction == XFER_READ)
2482                 dir = PCI_DMA_FROMDEVICE;
2483         else
2484                 dir = PCI_DMA_TODEVICE;
2485
2486         for (i = 0; i < seg; i++) {
2487                 c->SG[i].Len = tmp_sg[i].length;
2488                 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2489                                                   tmp_sg[i].offset,
2490                                                   tmp_sg[i].length, dir);
2491                 c->SG[i].Addr.lower = temp64.val32.lower;
2492                 c->SG[i].Addr.upper = temp64.val32.upper;
2493                 c->SG[i].Ext = 0;       // we are not chaining
2494         }
2495         /* track how many SG entries we are using */
2496         if (seg > h->maxSG)
2497                 h->maxSG = seg;
2498
2499 #ifdef CCISS_DEBUG
2500         printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2501                creq->nr_sectors, seg);
2502 #endif                          /* CCISS_DEBUG */
2503
2504         c->Header.SGList = c->Header.SGTotal = seg;
2505         if(h->cciss_read == CCISS_READ_10) {
2506                 c->Request.CDB[1] = 0;
2507                 c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
2508                 c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2509                 c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2510                 c->Request.CDB[5] = start_blk & 0xff;
2511                 c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
2512                 c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2513                 c->Request.CDB[8] = creq->nr_sectors & 0xff;
2514                 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2515         } else {
2516                 c->Request.CDBLen = 16;
2517                 c->Request.CDB[1]= 0;
2518                 c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
2519                 c->Request.CDB[3]= (start_blk >> 48) & 0xff;
2520                 c->Request.CDB[4]= (start_blk >> 40) & 0xff;
2521                 c->Request.CDB[5]= (start_blk >> 32) & 0xff;
2522                 c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2523                 c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2524                 c->Request.CDB[8]= (start_blk >>  8) & 0xff;
2525                 c->Request.CDB[9]= start_blk & 0xff;
2526                 c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
2527                 c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
2528                 c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
2529                 c->Request.CDB[13]= creq->nr_sectors & 0xff;
2530                 c->Request.CDB[14] = c->Request.CDB[15] = 0;
2531         }
2532
2533         spin_lock_irq(q->queue_lock);
2534
2535         addQ(&(h->reqQ), c);
2536         h->Qdepth++;
2537         if (h->Qdepth > h->maxQsinceinit)
2538                 h->maxQsinceinit = h->Qdepth;
2539
2540         goto queue;
2541 full:
2542         blk_stop_queue(q);
2543 startio:
2544         /* We will already have the driver lock here so not need
2545          * to lock it.
2546          */
2547         start_io(h);
2548 }
2549
2550 static inline unsigned long get_next_completion(ctlr_info_t *h)
2551 {
2552 #ifdef CONFIG_CISS_SCSI_TAPE
2553         /* Any rejects from sendcmd() lying around? Process them first */
2554         if (h->scsi_rejects.ncompletions == 0)
2555                 return h->access.command_completed(h);
2556         else {
2557                 struct sendcmd_reject_list *srl;
2558                 int n;
2559                 srl = &h->scsi_rejects;
2560                 n = --srl->ncompletions;
2561                 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2562                 printk("p");
2563                 return srl->complete[n];
2564         }
2565 #else
2566         return h->access.command_completed(h);
2567 #endif
2568 }
2569
2570 static inline int interrupt_pending(ctlr_info_t *h)
2571 {
2572 #ifdef CONFIG_CISS_SCSI_TAPE
2573         return (h->access.intr_pending(h)
2574                 || (h->scsi_rejects.ncompletions > 0));
2575 #else
2576         return h->access.intr_pending(h);
2577 #endif
2578 }
2579
2580 static inline long interrupt_not_for_us(ctlr_info_t *h)
2581 {
2582 #ifdef CONFIG_CISS_SCSI_TAPE
2583         return (((h->access.intr_pending(h) == 0) ||
2584                  (h->interrupts_enabled == 0))
2585                 && (h->scsi_rejects.ncompletions == 0));
2586 #else
2587         return (((h->access.intr_pending(h) == 0) ||
2588                  (h->interrupts_enabled == 0)));
2589 #endif
2590 }
2591
2592 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
2593 {
2594         ctlr_info_t *h = dev_id;
2595         CommandList_struct *c;
2596         unsigned long flags;
2597         __u32 a, a1, a2;
2598
2599         if (interrupt_not_for_us(h))
2600                 return IRQ_NONE;
2601         /*
2602          * If there are completed commands in the completion queue,
2603          * we had better do something about it.
2604          */
2605         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2606         while (interrupt_pending(h)) {
2607                 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
2608                         a1 = a;
2609                         if ((a & 0x04)) {
2610                                 a2 = (a >> 3);
2611                                 if (a2 >= h->nr_cmds) {
2612                                         printk(KERN_WARNING
2613                                                "cciss: controller cciss%d failed, stopping.\n",
2614                                                h->ctlr);
2615                                         fail_all_cmds(h->ctlr);
2616                                         return IRQ_HANDLED;
2617                                 }
2618
2619                                 c = h->cmd_pool + a2;
2620                                 a = c->busaddr;
2621
2622                         } else {
2623                                 a &= ~3;
2624                                 if ((c = h->cmpQ) == NULL) {
2625                                         printk(KERN_WARNING
2626                                                "cciss: Completion of %08x ignored\n",
2627                                                a1);
2628                                         continue;
2629                                 }
2630                                 while (c->busaddr != a) {
2631                                         c = c->next;
2632                                         if (c == h->cmpQ)
2633                                                 break;
2634                                 }
2635                         }
2636                         /*
2637                          * If we've found the command, take it off the
2638                          * completion Q and free it
2639                          */
2640                         if (c->busaddr == a) {
2641                                 removeQ(&h->cmpQ, c);
2642                                 if (c->cmd_type == CMD_RWREQ) {
2643                                         complete_command(h, c, 0);
2644                                 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2645                                         complete(c->waiting);
2646                                 }
2647 #                               ifdef CONFIG_CISS_SCSI_TAPE
2648                                 else if (c->cmd_type == CMD_SCSI)
2649                                         complete_scsi_command(c, 0, a1);
2650 #                               endif
2651                                 continue;
2652                         }
2653                 }
2654         }
2655
2656         spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2657         return IRQ_HANDLED;
2658 }
2659
2660 /*
2661  *  We cannot read the structure directly, for portability we must use
2662  *   the io functions.
2663  *   This is for debug only.
2664  */
2665 #ifdef CCISS_DEBUG
2666 static void print_cfg_table(CfgTable_struct *tb)
2667 {
2668         int i;
2669         char temp_name[17];
2670
2671         printk("Controller Configuration information\n");
2672         printk("------------------------------------\n");
2673         for (i = 0; i < 4; i++)
2674                 temp_name[i] = readb(&(tb->Signature[i]));
2675         temp_name[4] = '\0';
2676         printk("   Signature = %s\n", temp_name);
2677         printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));
2678         printk("   Transport methods supported = 0x%x\n",
2679                readl(&(tb->TransportSupport)));
2680         printk("   Transport methods active = 0x%x\n",
2681                readl(&(tb->TransportActive)));
2682         printk("   Requested transport Method = 0x%x\n",
2683                readl(&(tb->HostWrite.TransportRequest)));
2684         printk("   Coalesce Interrupt Delay = 0x%x\n",
2685                readl(&(tb->HostWrite.CoalIntDelay)));
2686         printk("   Coalesce Interrupt Count = 0x%x\n",
2687                readl(&(tb->HostWrite.CoalIntCount)));
2688         printk("   Max outstanding commands = 0x%d\n",
2689                readl(&(tb->CmdsOutMax)));
2690         printk("   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
2691         for (i = 0; i < 16; i++)
2692                 temp_name[i] = readb(&(tb->ServerName[i]));
2693         temp_name[16] = '\0';
2694         printk("   Server Name = %s\n", temp_name);
2695         printk("   Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
2696 }
2697 #endif                          /* CCISS_DEBUG */
2698
2699 static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
2700 {
2701         int i, offset, mem_type, bar_type;
2702         if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2703                 return 0;
2704         offset = 0;
2705         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
2706                 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
2707                 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2708                         offset += 4;
2709                 else {
2710                         mem_type = pci_resource_flags(pdev, i) &
2711                             PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2712                         switch (mem_type) {
2713                         case PCI_BASE_ADDRESS_MEM_TYPE_32:
2714                         case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2715                                 offset += 4;    /* 32 bit */
2716                                 break;
2717                         case PCI_BASE_ADDRESS_MEM_TYPE_64:
2718                                 offset += 8;
2719                                 break;
2720                         default:        /* reserved in PCI 2.2 */
2721                                 printk(KERN_WARNING
2722                                        "Base address is invalid\n");
2723                                 return -1;
2724                                 break;
2725                         }
2726                 }
2727                 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2728                         return i + 1;
2729         }
2730         return -1;
2731 }
2732
2733 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
2734  * controllers that are capable. If not, we use IO-APIC mode.
2735  */
2736
2737 static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
2738                                            struct pci_dev *pdev, __u32 board_id)
2739 {
2740 #ifdef CONFIG_PCI_MSI
2741         int err;
2742         struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
2743         {0, 2}, {0, 3}
2744         };
2745
2746         /* Some boards advertise MSI but don't really support it */
2747         if ((board_id == 0x40700E11) ||
2748             (board_id == 0x40800E11) ||
2749             (board_id == 0x40820E11) || (board_id == 0x40830E11))
2750                 goto default_int_mode;
2751
2752         if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
2753                 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
2754                 if (!err) {
2755                         c->intr[0] = cciss_msix_entries[0].vector;
2756                         c->intr[1] = cciss_msix_entries[1].vector;
2757                         c->intr[2] = cciss_msix_entries[2].vector;
2758                         c->intr[3] = cciss_msix_entries[3].vector;
2759                         c->msix_vector = 1;
2760                         return;
2761                 }
2762                 if (err > 0) {
2763                         printk(KERN_WARNING "cciss: only %d MSI-X vectors "
2764                                "available\n", err);
2765                 } else {
2766                         printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
2767                                err);
2768                 }
2769         }
2770         if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
2771                 if (!pci_enable_msi(pdev)) {
2772                         c->intr[SIMPLE_MODE_INT] = pdev->irq;
2773                         c->msi_vector = 1;
2774                         return;
2775                 } else {
2776                         printk(KERN_WARNING "cciss: MSI init failed\n");
2777                         c->intr[SIMPLE_MODE_INT] = pdev->irq;
2778                         return;
2779                 }
2780         }
2781       default_int_mode:
2782 #endif                          /* CONFIG_PCI_MSI */
2783         /* if we get here we're going to use the default interrupt mode */
2784         c->intr[SIMPLE_MODE_INT] = pdev->irq;
2785         return;
2786 }
2787
2788 static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2789 {
2790         ushort subsystem_vendor_id, subsystem_device_id, command;
2791         __u32 board_id, scratchpad = 0;
2792         __u64 cfg_offset;
2793         __u32 cfg_base_addr;
2794         __u64 cfg_base_addr_index;
2795         int i, err;
2796
2797         /* check to see if controller has been disabled */
2798         /* BEFORE trying to enable it */
2799         (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
2800         if (!(command & 0x02)) {
2801                 printk(KERN_WARNING
2802                        "cciss: controller appears to be disabled\n");
2803                 return -ENODEV;
2804         }
2805
2806         err = pci_enable_device(pdev);
2807         if (err) {
2808                 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2809                 return err;
2810         }
2811
2812         err = pci_request_regions(pdev, "cciss");
2813         if (err) {
2814                 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
2815                        "aborting\n");
2816                 goto err_out_disable_pdev;
2817         }
2818
2819         subsystem_vendor_id = pdev->subsystem_vendor;
2820         subsystem_device_id = pdev->subsystem_device;
2821         board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2822                     subsystem_vendor_id);
2823
2824 #ifdef CCISS_DEBUG
2825         printk("command = %x\n", command);
2826         printk("irq = %x\n", pdev->irq);
2827         printk("board_id = %x\n", board_id);
2828 #endif                          /* CCISS_DEBUG */
2829
2830 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
2831  * else we use the IO-APIC interrupt assigned to us by system ROM.
2832  */
2833         cciss_interrupt_mode(c, pdev, board_id);
2834
2835         /*
2836          * Memory base addr is first addr , the second points to the config
2837          *   table
2838          */
2839
2840         c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2841 #ifdef CCISS_DEBUG
2842         printk("address 0 = %x\n", c->paddr);
2843 #endif                          /* CCISS_DEBUG */
2844         c->vaddr = remap_pci_mem(c->paddr, 200);
2845
2846         /* Wait for the board to become ready.  (PCI hotplug needs this.)
2847          * We poll for up to 120 secs, once per 100ms. */
2848         for (i = 0; i < 1200; i++) {
2849                 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2850                 if (scratchpad == CCISS_FIRMWARE_READY)
2851                         break;
2852                 set_current_state(TASK_INTERRUPTIBLE);
2853                 schedule_timeout(HZ / 10);      /* wait 100ms */
2854         }
2855         if (scratchpad != CCISS_FIRMWARE_READY) {
2856                 printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");
2857                 err = -ENODEV;
2858                 goto err_out_free_res;
2859         }
2860
2861         /* get the address index number */
2862         cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2863         cfg_base_addr &= (__u32) 0x0000ffff;
2864 #ifdef CCISS_DEBUG
2865         printk("cfg base address = %x\n", cfg_base_addr);
2866 #endif                          /* CCISS_DEBUG */
2867         cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
2868 #ifdef CCISS_DEBUG
2869         printk("cfg base address index = %x\n", cfg_base_addr_index);
2870 #endif                          /* CCISS_DEBUG */
2871         if (cfg_base_addr_index == -1) {
2872                 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2873                 err = -ENODEV;
2874                 goto err_out_free_res;
2875         }
2876
2877         cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2878 #ifdef CCISS_DEBUG
2879         printk("cfg offset = %x\n", cfg_offset);
2880 #endif                          /* CCISS_DEBUG */
2881         c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2882                                                        cfg_base_addr_index) +
2883                                     cfg_offset, sizeof(CfgTable_struct));
2884         c->board_id = board_id;
2885
2886 #ifdef CCISS_DEBUG
2887         print_cfg_table(c->cfgtable);
2888 #endif                          /* CCISS_DEBUG */
2889
2890         for (i = 0; i < ARRAY_SIZE(products); i++) {
2891                 if (board_id == products[i].board_id) {
2892                         c->product_name = products[i].product_name;
2893                         c->access = *(products[i].access);
2894                         c->nr_cmds = products[i].nr_cmds;
2895                         break;
2896                 }
2897         }
2898         if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
2899             (readb(&c->cfgtable->Signature[1]) != 'I') ||
2900             (readb(&c->cfgtable->Signature[2]) != 'S') ||
2901             (readb(&c->cfgtable->Signature[3]) != 'S')) {
2902                 printk("Does not appear to be a valid CISS config table\n");
2903                 err = -ENODEV;
2904                 goto err_out_free_res;
2905         }
2906         /* We didn't find the controller in our list. We know the
2907          * signature is valid. If it's an HP device let's try to
2908          * bind to the device and fire it up. Otherwise we bail.
2909          */
2910         if (i == ARRAY_SIZE(products)) {
2911                 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
2912                         c->product_name = products[i-1].product_name;
2913                         c->access = *(products[i-1].access);
2914                         c->nr_cmds = products[i-1].nr_cmds;
2915                         printk(KERN_WARNING "cciss: This is an unknown "
2916                                 "Smart Array controller.\n"
2917                                 "cciss: Please update to the latest driver "
2918                                 "available from www.hp.com.\n");
2919                 } else {
2920                         printk(KERN_WARNING "cciss: Sorry, I don't know how"
2921                                 " to access the Smart Array controller %08lx\n"
2922                                         , (unsigned long)board_id);
2923                         err = -ENODEV;
2924                         goto err_out_free_res;
2925                 }
2926         }
2927 #ifdef CONFIG_X86
2928         {
2929                 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2930                 __u32 prefetch;
2931                 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
2932                 prefetch |= 0x100;
2933                 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
2934         }
2935 #endif
2936
2937         /* Disabling DMA prefetch for the P600
2938          * An ASIC bug may result in a prefetch beyond
2939          * physical memory.
2940          */
2941         if(board_id == 0x3225103C) {
2942                 __u32 dma_prefetch;
2943                 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
2944                 dma_prefetch |= 0x8000;
2945                 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
2946         }
2947
2948 #ifdef CCISS_DEBUG
2949         printk("Trying to put board into Simple mode\n");
2950 #endif                          /* CCISS_DEBUG */
2951         c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
2952         /* Update the field, and then ring the doorbell */
2953         writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
2954         writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
2955
2956         /* under certain very rare conditions, this can take awhile.
2957          * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2958          * as we enter this code.) */
2959         for (i = 0; i < MAX_CONFIG_WAIT; i++) {
2960                 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
2961                         break;
2962                 /* delay and try again */
2963                 set_current_state(TASK_INTERRUPTIBLE);
2964                 schedule_timeout(10);
2965         }
2966
2967 #ifdef CCISS_DEBUG
2968         printk(KERN_DEBUG "I counter got to %d %x\n", i,
2969                readl(c->vaddr + SA5_DOORBELL));
2970 #endif                          /* CCISS_DEBUG */
2971 #ifdef CCISS_DEBUG
2972         print_cfg_table(c->cfgtable);
2973 #endif                          /* CCISS_DEBUG */
2974
2975         if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
2976                 printk(KERN_WARNING "cciss: unable to get board into"
2977                        " simple mode\n");
2978                 err = -ENODEV;
2979                 goto err_out_free_res;
2980         }
2981         return 0;
2982
2983       err_out_free_res:
2984         pci_release_regions(pdev);
2985
2986       err_out_disable_pdev:
2987         pci_disable_device(pdev);
2988         return err;
2989 }
2990
2991 /*
2992  * Gets information about the local volumes attached to the controller.
2993  */
2994 static void cciss_getgeometry(int cntl_num)
2995 {
2996         ReportLunData_struct *ld_buff;
2997         InquiryData_struct *inq_buff;
2998         int return_code;
2999         int i;
3000         int listlength = 0;
3001         __u32 lunid = 0;
3002         int block_size;
3003         sector_t total_size;
3004
3005         ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
3006         if (ld_buff == NULL) {
3007                 printk(KERN_ERR "cciss: out of memory\n");
3008                 return;
3009         }
3010         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
3011         if (inq_buff == NULL) {
3012                 printk(KERN_ERR "cciss: out of memory\n");
3013                 kfree(ld_buff);
3014                 return;
3015         }
3016         /* Get the firmware version */
3017         return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
3018                               sizeof(InquiryData_struct), 0, 0, 0, NULL,
3019                               TYPE_CMD);
3020         if (return_code == IO_OK) {
3021                 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
3022                 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
3023                 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
3024                 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
3025         } else {                /* send command failed */
3026
3027                 printk(KERN_WARNING "cciss: unable to determine firmware"
3028                        " version of controller\n");
3029         }
3030         /* Get the number of logical volumes */
3031         return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
3032                               sizeof(ReportLunData_struct), 0, 0, 0, NULL,
3033                               TYPE_CMD);
3034
3035         if (return_code == IO_OK) {
3036 #ifdef CCISS_DEBUG
3037                 printk("LUN Data\n--------------------------\n");
3038 #endif                          /* CCISS_DEBUG */
3039
3040                 listlength |=
3041                     (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
3042                 listlength |=
3043                     (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
3044                 listlength |=
3045                     (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
3046                 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
3047         } else {                /* reading number of logical volumes failed */
3048
3049                 printk(KERN_WARNING "cciss: report logical volume"
3050                        " command failed\n");
3051                 listlength = 0;
3052         }
3053         hba[cntl_num]->num_luns = listlength / 8;       // 8 bytes pre entry
3054         if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
3055                 printk(KERN_ERR
3056                        "ciss:  only %d number of logical volumes supported\n",
3057                        CISS_MAX_LUN);
3058                 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3059         }
3060 #ifdef CCISS_DEBUG
3061         printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
3062                ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
3063                ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
3064                hba[cntl_num]->num_luns);
3065 #endif                          /* CCISS_DEBUG */
3066
3067         hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
3068         for (i = 0; i < CISS_MAX_LUN; i++) {
3069                 if (i < hba[cntl_num]->num_luns) {
3070                         lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3071                             << 24;
3072                         lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3073                             << 16;
3074                         lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3075                             << 8;
3076                         lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3077
3078                         hba[cntl_num]->drv[i].LunID = lunid;
3079
3080 #ifdef CCISS_DEBUG
3081                         printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i,
3082                                ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3083                                ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3084                                hba[cntl_num]->drv[i].LunID);
3085 #endif                          /* CCISS_DEBUG */
3086
3087                 /* testing to see if 16-byte CDBs are already being used */
3088                 if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
3089                         cciss_read_capacity_16(cntl_num, i, 0,
3090                                             &total_size, &block_size);
3091                         goto geo_inq;
3092                 }
3093                 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
3094
3095                 /* total_size = last LBA + 1 */
3096                 if(total_size == (__u32) 0) {
3097                         cciss_read_capacity_16(cntl_num, i, 0,
3098                         &total_size, &block_size);
3099                         hba[cntl_num]->cciss_read = CCISS_READ_16;
3100                         hba[cntl_num]->cciss_write = CCISS_WRITE_16;
3101                 } else {
3102                         hba[cntl_num]->cciss_read = CCISS_READ_10;
3103                         hba[cntl_num]->cciss_write = CCISS_WRITE_10;
3104                 }
3105 geo_inq:
3106                         cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3107                                                block_size, inq_buff,
3108                                                &hba[cntl_num]->drv[i]);
3109                 } else {
3110                         /* initialize raid_level to indicate a free space */
3111                         hba[cntl_num]->drv[i].raid_level = -1;
3112                 }
3113         }
3114         kfree(ld_buff);
3115         kfree(inq_buff);
3116 }
3117
3118 /* Function to find the first free pointer into our hba[] array */
3119 /* Returns -1 if no free entries are left.  */
3120 static int alloc_cciss_hba(void)
3121 {
3122         struct gendisk *disk[NWD];
3123         int i, n;
3124         for (n = 0; n < NWD; n++) {
3125                 disk[n] = alloc_disk(1 << NWD_SHIFT);
3126                 if (!disk[n])
3127                         goto out;
3128         }
3129
3130         for (i = 0; i < MAX_CTLR; i++) {
3131                 if (!hba[i]) {
3132                         ctlr_info_t *p;
3133                         p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3134                         if (!p)
3135                                 goto Enomem;
3136                         for (n = 0; n < NWD; n++)
3137                                 p->gendisk[n] = disk[n];
3138                         hba[i] = p;
3139                         return i;
3140                 }
3141         }
3142         printk(KERN_WARNING "cciss: This driver supports a maximum"
3143                " of %d controllers.\n", MAX_CTLR);
3144         goto out;
3145       Enomem:
3146         printk(KERN_ERR "cciss: out of memory.\n");
3147       out:
3148         while (n--)
3149                 put_disk(disk[n]);
3150         return -1;
3151 }
3152
3153 static void free_hba(int i)
3154 {
3155         ctlr_info_t *p = hba[i];
3156         int n;
3157
3158         hba[i] = NULL;
3159         for (n = 0; n < NWD; n++)
3160                 put_disk(p->gendisk[n]);
3161         kfree(p);
3162 }
3163
3164 /*
3165  *  This is it.  Find all the controllers and register them.  I really hate
3166  *  stealing all these major device numbers.
3167  *  returns the number of block devices registered.
3168  */
3169 static int __devinit cciss_init_one(struct pci_dev *pdev,
3170                                     const struct pci_device_id *ent)
3171 {
3172         request_queue_t *q;
3173         int i;
3174         int j;
3175         int rc;
3176         int dac;
3177
3178         i = alloc_cciss_hba();
3179         if (i < 0)
3180                 return -1;
3181
3182         hba[i]->busy_initializing = 1;
3183
3184         if (cciss_pci_init(hba[i], pdev) != 0)
3185                 goto clean1;
3186
3187         sprintf(hba[i]->devname, "cciss%d", i);
3188         hba[i]->ctlr = i;
3189         hba[i]->pdev = pdev;
3190
3191         /* configure PCI DMA stuff */
3192         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3193                 dac = 1;
3194         else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3195                 dac = 0;
3196         else {
3197                 printk(KERN_ERR "cciss: no suitable DMA available\n");
3198                 goto clean1;
3199         }
3200
3201         /*
3202          * register with the major number, or get a dynamic major number
3203          * by passing 0 as argument.  This is done for greater than
3204          * 8 controller support.
3205          */
3206         if (i < MAX_CTLR_ORIG)
3207                 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3208         rc = register_blkdev(hba[i]->major, hba[i]->devname);
3209         if (rc == -EBUSY || rc == -EINVAL) {
3210                 printk(KERN_ERR
3211                        "cciss:  Unable to get major number %d for %s "
3212                        "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3213                 goto clean1;
3214         } else {
3215                 if (i >= MAX_CTLR_ORIG)
3216                         hba[i]->major = rc;
3217         }
3218
3219         /* make sure the board interrupts are off */
3220         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3221         if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3222                         IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
3223                 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3224                        hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3225                 goto clean2;
3226         }
3227
3228         printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3229                hba[i]->devname, pdev->device, pci_name(pdev),
3230                hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3231
3232         hba[i]->cmd_pool_bits =
3233             kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
3234                       1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3235         hba[i]->cmd_pool = (CommandList_struct *)
3236             pci_alloc_consistent(hba[i]->pdev,
3237                     hba[i]->nr_cmds * sizeof(CommandList_struct),
3238                     &(hba[i]->cmd_pool_dhandle));
3239         hba[i]->errinfo_pool = (ErrorInfo_struct *)
3240             pci_alloc_consistent(hba[i]->pdev,
3241                     hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3242                     &(hba[i]->errinfo_pool_dhandle));
3243         if ((hba[i]->cmd_pool_bits == NULL)
3244             || (hba[i]->cmd_pool == NULL)
3245             || (hba[i]->errinfo_pool == NULL)) {
3246                 printk(KERN_ERR "cciss: out of memory");
3247                 goto clean4;
3248         }
3249 #ifdef CONFIG_CISS_SCSI_TAPE
3250         hba[i]->scsi_rejects.complete =
3251             kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3252                     (hba[i]->nr_cmds + 5), GFP_KERNEL);
3253         if (hba[i]->scsi_rejects.complete == NULL) {
3254                 printk(KERN_ERR "cciss: out of memory");
3255                 goto clean4;
3256         }
3257 #endif
3258         spin_lock_init(&hba[i]->lock);
3259
3260         /* Initialize the pdev driver private data.
3261            have it point to hba[i].  */
3262         pci_set_drvdata(pdev, hba[i]);
3263         /* command and error info recs zeroed out before
3264            they are used */
3265         memset(hba[i]->cmd_pool_bits, 0,
3266                ((hba[i]->nr_cmds + BITS_PER_LONG -
3267                  1) / BITS_PER_LONG) * sizeof(unsigned long));
3268
3269 #ifdef CCISS_DEBUG
3270         printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
3271 #endif                          /* CCISS_DEBUG */
3272
3273         cciss_getgeometry(i);
3274
3275         cciss_scsi_setup(i);
3276
3277         /* Turn the interrupts on so we can service requests */
3278         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3279
3280         cciss_procinit(i);
3281
3282         hba[i]->cciss_max_sectors = 2048;
3283
3284         hba[i]->busy_initializing = 0;
3285
3286         for (j = 0; j < NWD; j++) {     /* mfm */
3287                 drive_info_struct *drv = &(hba[i]->drv[j]);
3288                 struct gendisk *disk = hba[i]->gendisk[j];
3289
3290                 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3291                 if (!q) {
3292                         printk(KERN_ERR
3293                                "cciss:  unable to allocate queue for disk %d\n",
3294                                j);
3295                         break;
3296                 }
3297                 drv->queue = q;
3298
3299                 q->backing_dev_info.ra_pages = READ_AHEAD;
3300                 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3301
3302                 /* This is a hardware imposed limit. */
3303                 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3304
3305                 /* This is a limit in the driver and could be eliminated. */
3306                 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3307
3308                 blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
3309
3310                 blk_queue_softirq_done(q, cciss_softirq_done);
3311
3312                 q->queuedata = hba[i];
3313                 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3314                 disk->major = hba[i]->major;
3315                 disk->first_minor = j << NWD_SHIFT;
3316                 disk->fops = &cciss_fops;
3317                 disk->queue = q;
3318                 disk->private_data = drv;
3319                 disk->driverfs_dev = &pdev->dev;
3320                 /* we must register the controller even if no disks exist */
3321                 /* this is for the online array utilities */
3322                 if (!drv->heads && j)
3323                         continue;
3324                 blk_queue_hardsect_size(q, drv->block_size);
3325                 set_capacity(disk, drv->nr_blocks);
3326                 add_disk(disk);
3327         }
3328
3329         return 1;
3330
3331       clean4:
3332 #ifdef CONFIG_CISS_SCSI_TAPE
3333         kfree(hba[i]->scsi_rejects.complete);
3334 #endif
3335         kfree(hba[i]->cmd_pool_bits);
3336         if (hba[i]->cmd_pool)
3337                 pci_free_consistent(hba[i]->pdev,
3338                                     hba[i]->nr_cmds * sizeof(CommandList_struct),
3339                                     hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3340         if (hba[i]->errinfo_pool)
3341                 pci_free_consistent(hba[i]->pdev,
3342                                     hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3343                                     hba[i]->errinfo_pool,
3344                                     hba[i]->errinfo_pool_dhandle);
3345         free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3346       clean2:
3347         unregister_blkdev(hba[i]->major, hba[i]->devname);
3348       clean1:
3349         hba[i]->busy_initializing = 0;
3350         free_hba(i);
3351         return -1;
3352 }
3353
3354 static void __devexit cciss_remove_one(struct pci_dev *pdev)
3355 {
3356         ctlr_info_t *tmp_ptr;
3357         int i, j;
3358         char flush_buf[4];
3359         int return_code;
3360
3361         if (pci_get_drvdata(pdev) == NULL) {
3362                 printk(KERN_ERR "cciss: Unable to remove device \n");
3363                 return;
3364         }
3365         tmp_ptr = pci_get_drvdata(pdev);
3366         i = tmp_ptr->ctlr;
3367         if (hba[i] == NULL) {
3368                 printk(KERN_ERR "cciss: device appears to "
3369                        "already be removed \n");
3370                 return;
3371         }
3372         /* Turn board interrupts off  and send the flush cache command */
3373         /* sendcmd will turn off interrupt, and send the flush...
3374          * To write all data in the battery backed cache to disks */
3375         memset(flush_buf, 0, 4);
3376         return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3377                               TYPE_CMD);
3378         if (return_code != IO_OK) {
3379                 printk(KERN_WARNING "Error Flushing cache on controller %d\n",
3380                        i);
3381         }
3382         free_irq(hba[i]->intr[2], hba[i]);
3383
3384 #ifdef CONFIG_PCI_MSI
3385         if (hba[i]->msix_vector)
3386                 pci_disable_msix(hba[i]->pdev);
3387         else if (hba[i]->msi_vector)
3388                 pci_disable_msi(hba[i]->pdev);
3389 #endif                          /* CONFIG_PCI_MSI */
3390
3391         iounmap(hba[i]->vaddr);
3392         cciss_unregister_scsi(i);       /* unhook from SCSI subsystem */
3393         unregister_blkdev(hba[i]->major, hba[i]->devname);
3394         remove_proc_entry(hba[i]->devname, proc_cciss);
3395
3396         /* remove it from the disk list */
3397         for (j = 0; j < NWD; j++) {
3398                 struct gendisk *disk = hba[i]->gendisk[j];
3399                 if (disk) {
3400                         request_queue_t *q = disk->queue;
3401
3402                         if (disk->flags & GENHD_FL_UP)
3403                                 del_gendisk(disk);
3404                         if (q)
3405                                 blk_cleanup_queue(q);
3406                 }
3407         }
3408
3409         pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
3410                             hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3411         pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3412                             hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3413         kfree(hba[i]->cmd_pool_bits);
3414 #ifdef CONFIG_CISS_SCSI_TAPE
3415         kfree(hba[i]->scsi_rejects.complete);
3416 #endif
3417         pci_release_regions(pdev);
3418         pci_disable_device(pdev);
3419         pci_set_drvdata(pdev, NULL);
3420         free_hba(i);
3421 }
3422
3423 static struct pci_driver cciss_pci_driver = {
3424         .name = "cciss",
3425         .probe = cciss_init_one,
3426         .remove = __devexit_p(cciss_remove_one),
3427         .id_table = cciss_pci_device_id,        /* id_table */
3428 };
3429
3430 /*
3431  *  This is it.  Register the PCI driver information for the cards we control
3432  *  the OS will call our registered routines when it finds one of our cards.
3433  */
3434 static int __init cciss_init(void)
3435 {
3436         printk(KERN_INFO DRIVER_NAME "\n");
3437
3438         /* Register for our PCI devices */
3439         return pci_register_driver(&cciss_pci_driver);
3440 }
3441
3442 static void __exit cciss_cleanup(void)
3443 {
3444         int i;
3445
3446         pci_unregister_driver(&cciss_pci_driver);
3447         /* double check that all controller entrys have been removed */
3448         for (i = 0; i < MAX_CTLR; i++) {
3449                 if (hba[i] != NULL) {
3450                         printk(KERN_WARNING "cciss: had to remove"
3451                                " controller %d\n", i);
3452                         cciss_remove_one(hba[i]->pdev);
3453                 }
3454         }
3455         remove_proc_entry("cciss", proc_root_driver);
3456 }
3457
3458 static void fail_all_cmds(unsigned long ctlr)
3459 {
3460         /* If we get here, the board is apparently dead. */
3461         ctlr_info_t *h = hba[ctlr];
3462         CommandList_struct *c;
3463         unsigned long flags;
3464
3465         printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3466         h->alive = 0;           /* the controller apparently died... */
3467
3468         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3469
3470         pci_disable_device(h->pdev);    /* Make sure it is really dead. */
3471
3472         /* move everything off the request queue onto the completed queue */
3473         while ((c = h->reqQ) != NULL) {
3474                 removeQ(&(h->reqQ), c);
3475                 h->Qdepth--;
3476                 addQ(&(h->cmpQ), c);
3477         }
3478
3479         /* Now, fail everything on the completed queue with a HW error */
3480         while ((c = h->cmpQ) != NULL) {
3481                 removeQ(&h->cmpQ, c);
3482                 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3483                 if (c->cmd_type == CMD_RWREQ) {
3484                         complete_command(h, c, 0);
3485                 } else if (c->cmd_type == CMD_IOCTL_PEND)
3486                         complete(c->waiting);
3487 #ifdef CONFIG_CISS_SCSI_TAPE
3488                 else if (c->cmd_type == CMD_SCSI)
3489                         complete_scsi_command(c, 0, 0);
3490 #endif
3491         }
3492         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3493         return;
3494 }
3495
3496 module_init(cciss_init);
3497 module_exit(cciss_cleanup);