drivers/block/cciss.c

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