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