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