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         cciss_read_capacity(ctlr, drv_index, 1,
1295                             &total_size, &block_size);
1296
1297         /* total size = last LBA + 1 */
1298         /* FFFFFFFF + 1 = 0, cannot have a logical volume of size 0 */
1299         /* so we assume this volume this must be >2TB in size */
1300         if (total_size == (__u32) 0) {
1301                 cciss_read_capacity_16(ctlr, drv_index, 1,
1302                 &total_size, &block_size);
1303                 h->cciss_read = CCISS_READ_16;
1304                 h->cciss_write = CCISS_WRITE_16;
1305         } else {
1306                 h->cciss_read = CCISS_READ_10;
1307                 h->cciss_write = CCISS_WRITE_10;
1308         }
1309         cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1310                                inq_buff, &h->drv[drv_index]);
1311
1312         ++h->num_luns;
1313         disk = h->gendisk[drv_index];
1314         set_capacity(disk, h->drv[drv_index].nr_blocks);
1315
1316         /* if it's the controller it's already added */
1317         if (drv_index) {
1318                 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1319                 sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
1320                 disk->major = h->major;
1321                 disk->first_minor = drv_index << NWD_SHIFT;
1322                 disk->fops = &cciss_fops;
1323                 disk->private_data = &h->drv[drv_index];
1324
1325                 /* Set up queue information */
1326                 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1327                 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1328
1329                 /* This is a hardware imposed limit. */
1330                 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1331
1332                 /* This is a limit in the driver and could be eliminated. */
1333                 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1334
1335                 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
1336
1337                 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1338
1339                 disk->queue->queuedata = hba[ctlr];
1340
1341                 blk_queue_hardsect_size(disk->queue,
1342                                         hba[ctlr]->drv[drv_index].block_size);
1343
1344                 h->drv[drv_index].queue = disk->queue;
1345                 add_disk(disk);
1346         }
1347
1348       freeret:
1349         kfree(inq_buff);
1350         return;
1351       mem_msg:
1352         printk(KERN_ERR "cciss: out of memory\n");
1353         goto freeret;
1354 }
1355
1356 /* This function will find the first index of the controllers drive array
1357  * that has a -1 for the raid_level and will return that index.  This is
1358  * where new drives will be added.  If the index to be returned is greater
1359  * than the highest_lun index for the controller then highest_lun is set
1360  * to this new index.  If there are no available indexes then -1 is returned.
1361  */
1362 static int cciss_find_free_drive_index(int ctlr)
1363 {
1364         int i;
1365
1366         for (i = 0; i < CISS_MAX_LUN; i++) {
1367                 if (hba[ctlr]->drv[i].raid_level == -1) {
1368                         if (i > hba[ctlr]->highest_lun)
1369                                 hba[ctlr]->highest_lun = i;
1370                         return i;
1371                 }
1372         }
1373         return -1;
1374 }
1375
1376 /* This function will add and remove logical drives from the Logical
1377  * drive array of the controller and maintain persistency of ordering
1378  * so that mount points are preserved until the next reboot.  This allows
1379  * for the removal of logical drives in the middle of the drive array
1380  * without a re-ordering of those drives.
1381  * INPUT
1382  * h            = The controller to perform the operations on
1383  * del_disk     = The disk to remove if specified.  If the value given
1384  *                is NULL then no disk is removed.
1385  */
1386 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1387 {
1388         int ctlr = h->ctlr;
1389         int num_luns;
1390         ReportLunData_struct *ld_buff = NULL;
1391         drive_info_struct *drv = NULL;
1392         int return_code;
1393         int listlength = 0;
1394         int i;
1395         int drv_found;
1396         int drv_index = 0;
1397         __u32 lunid = 0;
1398         unsigned long flags;
1399
1400         /* Set busy_configuring flag for this operation */
1401         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1402         if (h->busy_configuring) {
1403                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1404                 return -EBUSY;
1405         }
1406         h->busy_configuring = 1;
1407
1408         /* if del_disk is NULL then we are being called to add a new disk
1409          * and update the logical drive table.  If it is not NULL then
1410          * we will check if the disk is in use or not.
1411          */
1412         if (del_disk != NULL) {
1413                 drv = get_drv(del_disk);
1414                 drv->busy_configuring = 1;
1415                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1416                 return_code = deregister_disk(del_disk, drv, 1);
1417                 drv->busy_configuring = 0;
1418                 h->busy_configuring = 0;
1419                 return return_code;
1420         } else {
1421                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1422                 if (!capable(CAP_SYS_RAWIO))
1423                         return -EPERM;
1424
1425                 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1426                 if (ld_buff == NULL)
1427                         goto mem_msg;
1428
1429                 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1430                                               sizeof(ReportLunData_struct), 0,
1431                                               0, 0, TYPE_CMD);
1432
1433                 if (return_code == IO_OK) {
1434                         listlength =
1435                                 be32_to_cpu(*(__u32 *) ld_buff->LUNListLength);
1436                 } else {        /* reading number of logical volumes failed */
1437                         printk(KERN_WARNING "cciss: report logical volume"
1438                                " command failed\n");
1439                         listlength = 0;
1440                         goto freeret;
1441                 }
1442
1443                 num_luns = listlength / 8;      /* 8 bytes per entry */
1444                 if (num_luns > CISS_MAX_LUN) {
1445                         num_luns = CISS_MAX_LUN;
1446                         printk(KERN_WARNING "cciss: more luns configured"
1447                                " on controller than can be handled by"
1448                                " this driver.\n");
1449                 }
1450
1451                 /* Compare controller drive array to drivers drive array.
1452                  * Check for updates in the drive information and any new drives
1453                  * on the controller.
1454                  */
1455                 for (i = 0; i < num_luns; i++) {
1456                         int j;
1457
1458                         drv_found = 0;
1459
1460                         lunid = (0xff &
1461                                  (unsigned int)(ld_buff->LUN[i][3])) << 24;
1462                         lunid |= (0xff &
1463                                   (unsigned int)(ld_buff->LUN[i][2])) << 16;
1464                         lunid |= (0xff &
1465                                   (unsigned int)(ld_buff->LUN[i][1])) << 8;
1466                         lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
1467
1468                         /* Find if the LUN is already in the drive array
1469                          * of the controller.  If so then update its info
1470                          * if not is use.  If it does not exist then find
1471                          * the first free index and add it.
1472                          */
1473                         for (j = 0; j <= h->highest_lun; j++) {
1474                                 if (h->drv[j].LunID == lunid) {
1475                                         drv_index = j;
1476                                         drv_found = 1;
1477                                 }
1478                         }
1479
1480                         /* check if the drive was found already in the array */
1481                         if (!drv_found) {
1482                                 drv_index = cciss_find_free_drive_index(ctlr);
1483                                 if (drv_index == -1)
1484                                         goto freeret;
1485
1486                                 /*Check if the gendisk needs to be allocated */
1487                                 if (!h->gendisk[drv_index]){
1488                                         h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT);
1489                                         if (!h->gendisk[drv_index]){
1490                                                 printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index);
1491                                                 goto mem_msg;
1492                                         }
1493                                 }
1494                         }
1495                         h->drv[drv_index].LunID = lunid;
1496                         cciss_update_drive_info(ctlr, drv_index);
1497                 }               /* end for */
1498         }                       /* end else */
1499
1500       freeret:
1501         kfree(ld_buff);
1502         h->busy_configuring = 0;
1503         /* We return -1 here to tell the ACU that we have registered/updated
1504          * all of the drives that we can and to keep it from calling us
1505          * additional times.
1506          */
1507         return -1;
1508       mem_msg:
1509         printk(KERN_ERR "cciss: out of memory\n");
1510         goto freeret;
1511 }
1512
1513 /* This function will deregister the disk and it's queue from the
1514  * kernel.  It must be called with the controller lock held and the
1515  * drv structures busy_configuring flag set.  It's parameters are:
1516  *
1517  * disk = This is the disk to be deregistered
1518  * drv  = This is the drive_info_struct associated with the disk to be
1519  *        deregistered.  It contains information about the disk used
1520  *        by the driver.
1521  * clear_all = This flag determines whether or not the disk information
1522  *             is going to be completely cleared out and the highest_lun
1523  *             reset.  Sometimes we want to clear out information about
1524  *             the disk in preparation for re-adding it.  In this case
1525  *             the highest_lun should be left unchanged and the LunID
1526  *             should not be cleared.
1527 */
1528 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1529                            int clear_all)
1530 {
1531         int i;
1532         ctlr_info_t *h = get_host(disk);
1533
1534         if (!capable(CAP_SYS_RAWIO))
1535                 return -EPERM;
1536
1537         /* make sure logical volume is NOT is use */
1538         if (clear_all || (h->gendisk[0] == disk)) {
1539                 if (drv->usage_count > 1)
1540                         return -EBUSY;
1541         } else if (drv->usage_count > 0)
1542                 return -EBUSY;
1543
1544         /* invalidate the devices and deregister the disk.  If it is disk
1545          * zero do not deregister it but just zero out it's values.  This
1546          * allows us to delete disk zero but keep the controller registered.
1547          */
1548         if (h->gendisk[0] != disk) {
1549                 if (disk) {
1550                         request_queue_t *q = disk->queue;
1551                         if (disk->flags & GENHD_FL_UP)
1552                                 del_gendisk(disk);
1553                         if (q) {
1554                                 blk_cleanup_queue(q);
1555                                 /* Set drv->queue to NULL so that we do not try
1556                                  * to call blk_start_queue on this queue in the
1557                                  * interrupt handler
1558                                  */
1559                                 drv->queue = NULL;
1560                         }
1561                         /* If clear_all is set then we are deleting the logical
1562                          * drive, not just refreshing its info.  For drives
1563                          * other than disk 0 we will call put_disk.  We do not
1564                          * do this for disk 0 as we need it to be able to
1565                          * configure the controller.
1566                         */
1567                         if (clear_all){
1568                                 /* This isn't pretty, but we need to find the
1569                                  * disk in our array and NULL our the pointer.
1570                                  * This is so that we will call alloc_disk if
1571                                  * this index is used again later.
1572                                 */
1573                                 for (i=0; i < CISS_MAX_LUN; i++){
1574                                         if(h->gendisk[i] == disk){
1575                                                 h->gendisk[i] = NULL;
1576                                                 break;
1577                                         }
1578                                 }
1579                                 put_disk(disk);
1580                         }
1581                 }
1582         } else {
1583                 set_capacity(disk, 0);
1584         }
1585
1586         --h->num_luns;
1587         /* zero out the disk size info */
1588         drv->nr_blocks = 0;
1589         drv->block_size = 0;
1590         drv->heads = 0;
1591         drv->sectors = 0;
1592         drv->cylinders = 0;
1593         drv->raid_level = -1;   /* This can be used as a flag variable to
1594                                  * indicate that this element of the drive
1595                                  * array is free.
1596                                  */
1597
1598         if (clear_all) {
1599                 /* check to see if it was the last disk */
1600                 if (drv == h->drv + h->highest_lun) {
1601                         /* if so, find the new hightest lun */
1602                         int i, newhighest = -1;
1603                         for (i = 0; i < h->highest_lun; i++) {
1604                                 /* if the disk has size > 0, it is available */
1605                                 if (h->drv[i].heads)
1606                                         newhighest = i;
1607                         }
1608                         h->highest_lun = newhighest;
1609                 }
1610
1611                 drv->LunID = 0;
1612         }
1613         return 0;
1614 }
1615
1616 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,
1617                                                                                                                            1: address logical volume log_unit,
1618                                                                                                                            2: periph device address is scsi3addr */
1619                     unsigned int log_unit, __u8 page_code,
1620                     unsigned char *scsi3addr, int cmd_type)
1621 {
1622         ctlr_info_t *h = hba[ctlr];
1623         u64bit buff_dma_handle;
1624         int status = IO_OK;
1625
1626         c->cmd_type = CMD_IOCTL_PEND;
1627         c->Header.ReplyQueue = 0;
1628         if (buff != NULL) {
1629                 c->Header.SGList = 1;
1630                 c->Header.SGTotal = 1;
1631         } else {
1632                 c->Header.SGList = 0;
1633                 c->Header.SGTotal = 0;
1634         }
1635         c->Header.Tag.lower = c->busaddr;
1636
1637         c->Request.Type.Type = cmd_type;
1638         if (cmd_type == TYPE_CMD) {
1639                 switch (cmd) {
1640                 case CISS_INQUIRY:
1641                         /* If the logical unit number is 0 then, this is going
1642                            to controller so It's a physical command
1643                            mode = 0 target = 0.  So we have nothing to write.
1644                            otherwise, if use_unit_num == 1,
1645                            mode = 1(volume set addressing) target = LUNID
1646                            otherwise, if use_unit_num == 2,
1647                            mode = 0(periph dev addr) target = scsi3addr */
1648                         if (use_unit_num == 1) {
1649                                 c->Header.LUN.LogDev.VolId =
1650                                     h->drv[log_unit].LunID;
1651                                 c->Header.LUN.LogDev.Mode = 1;
1652                         } else if (use_unit_num == 2) {
1653                                 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1654                                        8);
1655                                 c->Header.LUN.LogDev.Mode = 0;
1656                         }
1657                         /* are we trying to read a vital product page */
1658                         if (page_code != 0) {
1659                                 c->Request.CDB[1] = 0x01;
1660                                 c->Request.CDB[2] = page_code;
1661                         }
1662                         c->Request.CDBLen = 6;
1663                         c->Request.Type.Attribute = ATTR_SIMPLE;
1664                         c->Request.Type.Direction = XFER_READ;
1665                         c->Request.Timeout = 0;
1666                         c->Request.CDB[0] = CISS_INQUIRY;
1667                         c->Request.CDB[4] = size & 0xFF;
1668                         break;
1669                 case CISS_REPORT_LOG:
1670                 case CISS_REPORT_PHYS:
1671                         /* Talking to controller so It's a physical command
1672                            mode = 00 target = 0.  Nothing to write.
1673                          */
1674                         c->Request.CDBLen = 12;
1675                         c->Request.Type.Attribute = ATTR_SIMPLE;
1676                         c->Request.Type.Direction = XFER_READ;
1677                         c->Request.Timeout = 0;
1678                         c->Request.CDB[0] = cmd;
1679                         c->Request.CDB[6] = (size >> 24) & 0xFF;        //MSB
1680                         c->Request.CDB[7] = (size >> 16) & 0xFF;
1681                         c->Request.CDB[8] = (size >> 8) & 0xFF;
1682                         c->Request.CDB[9] = size & 0xFF;
1683                         break;
1684
1685                 case CCISS_READ_CAPACITY:
1686                         c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1687                         c->Header.LUN.LogDev.Mode = 1;
1688                         c->Request.CDBLen = 10;
1689                         c->Request.Type.Attribute = ATTR_SIMPLE;
1690                         c->Request.Type.Direction = XFER_READ;
1691                         c->Request.Timeout = 0;
1692                         c->Request.CDB[0] = cmd;
1693                         break;
1694                 case CCISS_READ_CAPACITY_16:
1695                         c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1696                         c->Header.LUN.LogDev.Mode = 1;
1697                         c->Request.CDBLen = 16;
1698                         c->Request.Type.Attribute = ATTR_SIMPLE;
1699                         c->Request.Type.Direction = XFER_READ;
1700                         c->Request.Timeout = 0;
1701                         c->Request.CDB[0] = cmd;
1702                         c->Request.CDB[1] = 0x10;
1703                         c->Request.CDB[10] = (size >> 24) & 0xFF;
1704                         c->Request.CDB[11] = (size >> 16) & 0xFF;
1705                         c->Request.CDB[12] = (size >> 8) & 0xFF;
1706                         c->Request.CDB[13] = size & 0xFF;
1707                         c->Request.Timeout = 0;
1708                         c->Request.CDB[0] = cmd;
1709                         break;
1710                 case CCISS_CACHE_FLUSH:
1711                         c->Request.CDBLen = 12;
1712                         c->Request.Type.Attribute = ATTR_SIMPLE;
1713                         c->Request.Type.Direction = XFER_WRITE;
1714                         c->Request.Timeout = 0;
1715                         c->Request.CDB[0] = BMIC_WRITE;
1716                         c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1717                         break;
1718                 default:
1719                         printk(KERN_WARNING
1720                                "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
1721                         return IO_ERROR;
1722                 }
1723         } else if (cmd_type == TYPE_MSG) {
1724                 switch (cmd) {
1725                 case 0: /* ABORT message */
1726                         c->Request.CDBLen = 12;
1727                         c->Request.Type.Attribute = ATTR_SIMPLE;
1728                         c->Request.Type.Direction = XFER_WRITE;
1729                         c->Request.Timeout = 0;
1730                         c->Request.CDB[0] = cmd;        /* abort */
1731                         c->Request.CDB[1] = 0;  /* abort a command */
1732                         /* buff contains the tag of the command to abort */
1733                         memcpy(&c->Request.CDB[4], buff, 8);
1734                         break;
1735                 case 1: /* RESET message */
1736                         c->Request.CDBLen = 12;
1737                         c->Request.Type.Attribute = ATTR_SIMPLE;
1738                         c->Request.Type.Direction = XFER_WRITE;
1739                         c->Request.Timeout = 0;
1740                         memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1741                         c->Request.CDB[0] = cmd;        /* reset */
1742                         c->Request.CDB[1] = 0x04;       /* reset a LUN */
1743                         break;
1744                 case 3: /* No-Op message */
1745                         c->Request.CDBLen = 1;
1746                         c->Request.Type.Attribute = ATTR_SIMPLE;
1747                         c->Request.Type.Direction = XFER_WRITE;
1748                         c->Request.Timeout = 0;
1749                         c->Request.CDB[0] = cmd;
1750                         break;
1751                 default:
1752                         printk(KERN_WARNING
1753                                "cciss%d: unknown message type %d\n", ctlr, cmd);
1754                         return IO_ERROR;
1755                 }
1756         } else {
1757                 printk(KERN_WARNING
1758                        "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1759                 return IO_ERROR;
1760         }
1761         /* Fill in the scatter gather information */
1762         if (size > 0) {
1763                 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1764                                                              buff, size,
1765                                                              PCI_DMA_BIDIRECTIONAL);
1766                 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1767                 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1768                 c->SG[0].Len = size;
1769                 c->SG[0].Ext = 0;       /* we are not chaining */
1770         }
1771         return status;
1772 }
1773
1774 static int sendcmd_withirq(__u8 cmd,
1775                            int ctlr,
1776                            void *buff,
1777                            size_t size,
1778                            unsigned int use_unit_num,
1779                            unsigned int log_unit, __u8 page_code, int cmd_type)
1780 {
1781         ctlr_info_t *h = hba[ctlr];
1782         CommandList_struct *c;
1783         u64bit buff_dma_handle;
1784         unsigned long flags;
1785         int return_status;
1786         DECLARE_COMPLETION_ONSTACK(wait);
1787
1788         if ((c = cmd_alloc(h, 0)) == NULL)
1789                 return -ENOMEM;
1790         return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1791                                  log_unit, page_code, NULL, cmd_type);
1792         if (return_status != IO_OK) {
1793                 cmd_free(h, c, 0);
1794                 return return_status;
1795         }
1796       resend_cmd2:
1797         c->waiting = &wait;
1798
1799         /* Put the request on the tail of the queue and send it */
1800         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1801         addQ(&h->reqQ, c);
1802         h->Qdepth++;
1803         start_io(h);
1804         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1805
1806         wait_for_completion(&wait);
1807
1808         if (c->err_info->CommandStatus != 0) {  /* an error has occurred */
1809                 switch (c->err_info->CommandStatus) {
1810                 case CMD_TARGET_STATUS:
1811                         printk(KERN_WARNING "cciss: cmd %p has "
1812                                " completed with errors\n", c);
1813                         if (c->err_info->ScsiStatus) {
1814                                 printk(KERN_WARNING "cciss: cmd %p "
1815                                        "has SCSI Status = %x\n",
1816                                        c, c->err_info->ScsiStatus);
1817                         }
1818
1819                         break;
1820                 case CMD_DATA_UNDERRUN:
1821                 case CMD_DATA_OVERRUN:
1822                         /* expected for inquire and report lun commands */
1823                         break;
1824                 case CMD_INVALID:
1825                         printk(KERN_WARNING "cciss: Cmd %p is "
1826                                "reported invalid\n", c);
1827                         return_status = IO_ERROR;
1828                         break;
1829                 case CMD_PROTOCOL_ERR:
1830                         printk(KERN_WARNING "cciss: cmd %p has "
1831                                "protocol error \n", c);
1832                         return_status = IO_ERROR;
1833                         break;
1834                 case CMD_HARDWARE_ERR:
1835                         printk(KERN_WARNING "cciss: cmd %p had "
1836                                " hardware error\n", c);
1837                         return_status = IO_ERROR;
1838                         break;
1839                 case CMD_CONNECTION_LOST:
1840                         printk(KERN_WARNING "cciss: cmd %p had "
1841                                "connection lost\n", c);
1842                         return_status = IO_ERROR;
1843                         break;
1844                 case CMD_ABORTED:
1845                         printk(KERN_WARNING "cciss: cmd %p was "
1846                                "aborted\n", c);
1847                         return_status = IO_ERROR;
1848                         break;
1849                 case CMD_ABORT_FAILED:
1850                         printk(KERN_WARNING "cciss: cmd %p reports "
1851                                "abort failed\n", c);
1852                         return_status = IO_ERROR;
1853                         break;
1854                 case CMD_UNSOLICITED_ABORT:
1855                         printk(KERN_WARNING
1856                                "cciss%d: unsolicited abort %p\n", ctlr, c);
1857                         if (c->retry_count < MAX_CMD_RETRIES) {
1858                                 printk(KERN_WARNING
1859                                        "cciss%d: retrying %p\n", ctlr, c);
1860                                 c->retry_count++;
1861                                 /* erase the old error information */
1862                                 memset(c->err_info, 0,
1863                                        sizeof(ErrorInfo_struct));
1864                                 return_status = IO_OK;
1865                                 INIT_COMPLETION(wait);
1866                                 goto resend_cmd2;
1867                         }
1868                         return_status = IO_ERROR;
1869                         break;
1870                 default:
1871                         printk(KERN_WARNING "cciss: cmd %p returned "
1872                                "unknown status %x\n", c,
1873                                c->err_info->CommandStatus);
1874                         return_status = IO_ERROR;
1875                 }
1876         }
1877         /* unlock the buffers from DMA */
1878         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1879         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1880         pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
1881                          c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1882         cmd_free(h, c, 0);
1883         return return_status;
1884 }
1885
1886 static void cciss_geometry_inquiry(int ctlr, int logvol,
1887                                    int withirq, sector_t total_size,
1888                                    unsigned int block_size,
1889                                    InquiryData_struct *inq_buff,
1890                                    drive_info_struct *drv)
1891 {
1892         int return_code;
1893         unsigned long t;
1894
1895         memset(inq_buff, 0, sizeof(InquiryData_struct));
1896         if (withirq)
1897                 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1898                                               inq_buff, sizeof(*inq_buff), 1,
1899                                               logvol, 0xC1, TYPE_CMD);
1900         else
1901                 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1902                                       sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
1903                                       TYPE_CMD);
1904         if (return_code == IO_OK) {
1905                 if (inq_buff->data_byte[8] == 0xFF) {
1906                         printk(KERN_WARNING
1907                                "cciss: reading geometry failed, volume "
1908                                "does not support reading geometry\n");
1909                         drv->heads = 255;
1910                         drv->sectors = 32;      // Sectors per track
1911                         drv->raid_level = RAID_UNKNOWN;
1912                 } else {
1913                         drv->heads = inq_buff->data_byte[6];
1914                         drv->sectors = inq_buff->data_byte[7];
1915                         drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1916                         drv->cylinders += inq_buff->data_byte[5];
1917                         drv->raid_level = inq_buff->data_byte[8];
1918                 }
1919                 drv->block_size = block_size;
1920                 drv->nr_blocks = total_size;
1921                 t = drv->heads * drv->sectors;
1922                 if (t > 1) {
1923                         unsigned rem = sector_div(total_size, t);
1924                         if (rem)
1925                                 total_size++;
1926                         drv->cylinders = total_size;
1927                 }
1928         } else {                /* Get geometry failed */
1929                 printk(KERN_WARNING "cciss: reading geometry failed\n");
1930         }
1931         printk(KERN_INFO "      heads=%d, sectors=%d, cylinders=%d\n\n",
1932                drv->heads, drv->sectors, drv->cylinders);
1933 }
1934
1935 static void
1936 cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
1937                     unsigned int *block_size)
1938 {
1939         ReadCapdata_struct *buf;
1940         int return_code;
1941         buf = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
1942         if (buf == NULL) {
1943                 printk(KERN_WARNING "cciss: out of memory\n");
1944                 return;
1945         }
1946         memset(buf, 0, sizeof(ReadCapdata_struct));
1947         if (withirq)
1948                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1949                                 ctlr, buf, sizeof(ReadCapdata_struct),
1950                                         1, logvol, 0, TYPE_CMD);
1951         else
1952                 return_code = sendcmd(CCISS_READ_CAPACITY,
1953                                 ctlr, buf, sizeof(ReadCapdata_struct),
1954                                         1, logvol, 0, NULL, TYPE_CMD);
1955         if (return_code == IO_OK) {
1956                 *total_size = be32_to_cpu(*(__u32 *) buf->total_size)+1;
1957                 *block_size = be32_to_cpu(*(__u32 *) buf->block_size);
1958         } else {                /* read capacity command failed */
1959                 printk(KERN_WARNING "cciss: read capacity failed\n");
1960                 *total_size = 0;
1961                 *block_size = BLOCK_SIZE;
1962         }
1963         if (*total_size != (__u32) 0)
1964                 printk(KERN_INFO "      blocks= %llu block_size= %d\n",
1965                 (unsigned long long)*total_size, *block_size);
1966         kfree(buf);
1967         return;
1968 }
1969
1970 static void
1971 cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,                                 unsigned int *block_size)
1972 {
1973         ReadCapdata_struct_16 *buf;
1974         int return_code;
1975         buf = kmalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
1976         if (buf == NULL) {
1977                 printk(KERN_WARNING "cciss: out of memory\n");
1978                 return;
1979         }
1980         memset(buf, 0, sizeof(ReadCapdata_struct_16));
1981         if (withirq) {
1982                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
1983                         ctlr, buf, sizeof(ReadCapdata_struct_16),
1984                                 1, logvol, 0, TYPE_CMD);
1985         }
1986         else {
1987                 return_code = sendcmd(CCISS_READ_CAPACITY_16,
1988                         ctlr, buf, sizeof(ReadCapdata_struct_16),
1989                                 1, logvol, 0, NULL, TYPE_CMD);
1990         }
1991         if (return_code == IO_OK) {
1992                 *total_size = be64_to_cpu(*(__u64 *) buf->total_size)+1;
1993                 *block_size = be32_to_cpu(*(__u32 *) buf->block_size);
1994         } else {                /* read capacity command failed */
1995                 printk(KERN_WARNING "cciss: read capacity failed\n");
1996                 *total_size = 0;
1997                 *block_size = BLOCK_SIZE;
1998         }
1999         printk(KERN_INFO "      blocks= %llu block_size= %d\n",
2000                (unsigned long long)*total_size, *block_size);
2001         kfree(buf);
2002         return;
2003 }
2004
2005 static int cciss_revalidate(struct gendisk *disk)
2006 {
2007         ctlr_info_t *h = get_host(disk);
2008         drive_info_struct *drv = get_drv(disk);
2009         int logvol;
2010         int FOUND = 0;
2011         unsigned int block_size;
2012         sector_t total_size;
2013         InquiryData_struct *inq_buff = NULL;
2014
2015         for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
2016                 if (h->drv[logvol].LunID == drv->LunID) {
2017                         FOUND = 1;
2018                         break;
2019                 }
2020         }
2021
2022         if (!FOUND)
2023                 return 1;
2024
2025         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
2026         if (inq_buff == NULL) {
2027                 printk(KERN_WARNING "cciss: out of memory\n");
2028                 return 1;
2029         }
2030         if (h->cciss_read == CCISS_READ_10) {
2031                 cciss_read_capacity(h->ctlr, logvol, 1,
2032                                         &total_size, &block_size);
2033         } else {
2034                 cciss_read_capacity_16(h->ctlr, logvol, 1,
2035                                         &total_size, &block_size);
2036         }
2037         cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2038                                inq_buff, drv);
2039
2040         blk_queue_hardsect_size(drv->queue, drv->block_size);
2041         set_capacity(disk, drv->nr_blocks);
2042
2043         kfree(inq_buff);
2044         return 0;
2045 }
2046
2047 /*
2048  *   Wait polling for a command to complete.
2049  *   The memory mapped FIFO is polled for the completion.
2050  *   Used only at init time, interrupts from the HBA are disabled.
2051  */
2052 static unsigned long pollcomplete(int ctlr)
2053 {
2054         unsigned long done;
2055         int i;
2056
2057         /* Wait (up to 20 seconds) for a command to complete */
2058
2059         for (i = 20 * HZ; i > 0; i--) {
2060                 done = hba[ctlr]->access.command_completed(hba[ctlr]);
2061                 if (done == FIFO_EMPTY)
2062                         schedule_timeout_uninterruptible(1);
2063                 else
2064                         return done;
2065         }
2066         /* Invalid address to tell caller we ran out of time */
2067         return 1;
2068 }
2069
2070 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2071 {
2072         /* We get in here if sendcmd() is polling for completions
2073            and gets some command back that it wasn't expecting --
2074            something other than that which it just sent down.
2075            Ordinarily, that shouldn't happen, but it can happen when
2076            the scsi tape stuff gets into error handling mode, and
2077            starts using sendcmd() to try to abort commands and
2078            reset tape drives.  In that case, sendcmd may pick up
2079            completions of commands that were sent to logical drives
2080            through the block i/o system, or cciss ioctls completing, etc.
2081            In that case, we need to save those completions for later
2082            processing by the interrupt handler.
2083          */
2084
2085 #ifdef CONFIG_CISS_SCSI_TAPE
2086         struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
2087
2088         /* If it's not the scsi tape stuff doing error handling, (abort */
2089         /* or reset) then we don't expect anything weird. */
2090         if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2091 #endif
2092                 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2093                        "Invalid command list address returned! (%lx)\n",
2094                        ctlr, complete);
2095                 /* not much we can do. */
2096 #ifdef CONFIG_CISS_SCSI_TAPE
2097                 return 1;
2098         }
2099
2100         /* We've sent down an abort or reset, but something else
2101            has completed */
2102         if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
2103                 /* Uh oh.  No room to save it for later... */
2104                 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
2105                        "reject list overflow, command lost!\n", ctlr);
2106                 return 1;
2107         }
2108         /* Save it for later */
2109         srl->complete[srl->ncompletions] = complete;
2110         srl->ncompletions++;
2111 #endif
2112         return 0;
2113 }
2114
2115 /*
2116  * Send a command to the controller, and wait for it to complete.
2117  * Only used at init time.
2118  */
2119 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
2120                                                                                                    1: address logical volume log_unit,
2121                                                                                                    2: periph device address is scsi3addr */
2122                    unsigned int log_unit,
2123                    __u8 page_code, unsigned char *scsi3addr, int cmd_type)
2124 {
2125         CommandList_struct *c;
2126         int i;
2127         unsigned long complete;
2128         ctlr_info_t *info_p = hba[ctlr];
2129         u64bit buff_dma_handle;
2130         int status, done = 0;
2131
2132         if ((c = cmd_alloc(info_p, 1)) == NULL) {
2133                 printk(KERN_WARNING "cciss: unable to get memory");
2134                 return IO_ERROR;
2135         }
2136         status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2137                           log_unit, page_code, scsi3addr, cmd_type);
2138         if (status != IO_OK) {
2139                 cmd_free(info_p, c, 1);
2140                 return status;
2141         }
2142       resend_cmd1:
2143         /*
2144          * Disable interrupt
2145          */
2146 #ifdef CCISS_DEBUG
2147         printk(KERN_DEBUG "cciss: turning intr off\n");
2148 #endif                          /* CCISS_DEBUG */
2149         info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2150
2151         /* Make sure there is room in the command FIFO */
2152         /* Actually it should be completely empty at this time */
2153         /* unless we are in here doing error handling for the scsi */
2154         /* tape side of the driver. */
2155         for (i = 200000; i > 0; i--) {
2156                 /* if fifo isn't full go */
2157                 if (!(info_p->access.fifo_full(info_p))) {
2158
2159                         break;
2160                 }
2161                 udelay(10);
2162                 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2163                        " waiting!\n", ctlr);
2164         }
2165         /*
2166          * Send the cmd
2167          */
2168         info_p->access.submit_command(info_p, c);
2169         done = 0;
2170         do {
2171                 complete = pollcomplete(ctlr);
2172
2173 #ifdef CCISS_DEBUG
2174                 printk(KERN_DEBUG "cciss: command completed\n");
2175 #endif                          /* CCISS_DEBUG */
2176
2177                 if (complete == 1) {
2178                         printk(KERN_WARNING
2179                                "cciss cciss%d: SendCmd Timeout out, "
2180                                "No command list address returned!\n", ctlr);
2181                         status = IO_ERROR;
2182                         done = 1;
2183                         break;
2184                 }
2185
2186                 /* This will need to change for direct lookup completions */
2187                 if ((complete & CISS_ERROR_BIT)
2188                     && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2189                         /* if data overrun or underun on Report command
2190                            ignore it
2191                          */
2192                         if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2193                              (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2194                              (c->Request.CDB[0] == CISS_INQUIRY)) &&
2195                             ((c->err_info->CommandStatus ==
2196                               CMD_DATA_OVERRUN) ||
2197                              (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2198                             )) {
2199                                 complete = c->busaddr;
2200                         } else {
2201                                 if (c->err_info->CommandStatus ==
2202                                     CMD_UNSOLICITED_ABORT) {
2203                                         printk(KERN_WARNING "cciss%d: "
2204                                                "unsolicited abort %p\n",
2205                                                ctlr, c);
2206                                         if (c->retry_count < MAX_CMD_RETRIES) {
2207                                                 printk(KERN_WARNING
2208                                                        "cciss%d: retrying %p\n",
2209                                                        ctlr, c);
2210                                                 c->retry_count++;
2211                                                 /* erase the old error */
2212                                                 /* information */
2213                                                 memset(c->err_info, 0,
2214                                                        sizeof
2215                                                        (ErrorInfo_struct));
2216                                                 goto resend_cmd1;
2217                                         } else {
2218                                                 printk(KERN_WARNING
2219                                                        "cciss%d: retried %p too "
2220                                                        "many times\n", ctlr, c);
2221                                                 status = IO_ERROR;
2222                                                 goto cleanup1;
2223                                         }
2224                                 } else if (c->err_info->CommandStatus ==
2225                                            CMD_UNABORTABLE) {
2226                                         printk(KERN_WARNING
2227                                                "cciss%d: command could not be aborted.\n",
2228                                                ctlr);
2229                                         status = IO_ERROR;
2230                                         goto cleanup1;
2231                                 }
2232                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2233                                        " Error %x \n", ctlr,
2234                                        c->err_info->CommandStatus);
2235                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2236                                        " offensive info\n"
2237                                        "  size %x\n   num %x   value %x\n",
2238                                        ctlr,
2239                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2240                                        offense_size,
2241                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2242                                        offense_num,
2243                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2244                                        offense_value);
2245                                 status = IO_ERROR;
2246                                 goto cleanup1;
2247                         }
2248                 }
2249                 /* This will need changing for direct lookup completions */
2250                 if (complete != c->busaddr) {
2251                         if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2252                                 BUG();  /* we are pretty much hosed if we get here. */
2253                         }
2254                         continue;
2255                 } else
2256                         done = 1;
2257         } while (!done);
2258
2259       cleanup1:
2260         /* unlock the data buffer from DMA */
2261         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2262         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2263         pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2264                          c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2265 #ifdef CONFIG_CISS_SCSI_TAPE
2266         /* if we saved some commands for later, process them now. */
2267         if (info_p->scsi_rejects.ncompletions > 0)
2268                 do_cciss_intr(0, info_p);
2269 #endif
2270         cmd_free(info_p, c, 1);
2271         return status;
2272 }
2273
2274 /*
2275  * Map (physical) PCI mem into (virtual) kernel space
2276  */
2277 static void __iomem *remap_pci_mem(ulong base, ulong size)
2278 {
2279         ulong page_base = ((ulong) base) & PAGE_MASK;
2280         ulong page_offs = ((ulong) base) - page_base;
2281         void __iomem *page_remapped = ioremap(page_base, page_offs + size);
2282
2283         return page_remapped ? (page_remapped + page_offs) : NULL;
2284 }
2285
2286 /*
2287  * Takes jobs of the Q and sends them to the hardware, then puts it on
2288  * the Q to wait for completion.
2289  */
2290 static void start_io(ctlr_info_t *h)
2291 {
2292         CommandList_struct *c;
2293
2294         while ((c = h->reqQ) != NULL) {
2295                 /* can't do anything if fifo is full */
2296                 if ((h->access.fifo_full(h))) {
2297                         printk(KERN_WARNING "cciss: fifo full\n");
2298                         break;
2299                 }
2300
2301                 /* Get the first entry from the Request Q */
2302                 removeQ(&(h->reqQ), c);
2303                 h->Qdepth--;
2304
2305                 /* Tell the controller execute command */
2306                 h->access.submit_command(h, c);
2307
2308                 /* Put job onto the completed Q */
2309                 addQ(&(h->cmpQ), c);
2310         }
2311 }
2312
2313 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2314 /* Zeros out the error record and then resends the command back */
2315 /* to the controller */
2316 static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
2317 {
2318         /* erase the old error information */
2319         memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2320
2321         /* add it to software queue and then send it to the controller */
2322         addQ(&(h->reqQ), c);
2323         h->Qdepth++;
2324         if (h->Qdepth > h->maxQsinceinit)
2325                 h->maxQsinceinit = h->Qdepth;
2326
2327         start_io(h);
2328 }
2329
2330 /* checks the status of the job and calls complete buffers to mark all
2331  * buffers for the completed job. Note that this function does not need
2332  * to hold the hba/queue lock.
2333  */
2334 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2335                                     int timeout)
2336 {
2337         int status = 1;
2338         int retry_cmd = 0;
2339
2340         if (timeout)
2341                 status = 0;
2342
2343         if (cmd->err_info->CommandStatus != 0) {        /* an error has occurred */
2344                 switch (cmd->err_info->CommandStatus) {
2345                         unsigned char sense_key;
2346                 case CMD_TARGET_STATUS:
2347                         status = 0;
2348
2349                         if (cmd->err_info->ScsiStatus == 0x02) {
2350                                 printk(KERN_WARNING "cciss: cmd %p "
2351                                        "has CHECK CONDITION "
2352                                        " byte 2 = 0x%x\n", cmd,
2353                                        cmd->err_info->SenseInfo[2]
2354                                     );
2355                                 /* check the sense key */
2356                                 sense_key = 0xf & cmd->err_info->SenseInfo[2];
2357                                 /* no status or recovered error */
2358                                 if ((sense_key == 0x0) || (sense_key == 0x1)) {
2359                                         status = 1;
2360                                 }
2361                         } else {
2362                                 printk(KERN_WARNING "cciss: cmd %p "
2363                                        "has SCSI Status 0x%x\n",
2364                                        cmd, cmd->err_info->ScsiStatus);
2365                         }
2366                         break;
2367                 case CMD_DATA_UNDERRUN:
2368                         printk(KERN_WARNING "cciss: cmd %p has"
2369                                " completed with data underrun "
2370                                "reported\n", cmd);
2371                         break;
2372                 case CMD_DATA_OVERRUN:
2373                         printk(KERN_WARNING "cciss: cmd %p has"
2374                                " completed with data overrun "
2375                                "reported\n", cmd);
2376                         break;
2377                 case CMD_INVALID:
2378                         printk(KERN_WARNING "cciss: cmd %p is "
2379                                "reported invalid\n", cmd);
2380                         status = 0;
2381                         break;
2382                 case CMD_PROTOCOL_ERR:
2383                         printk(KERN_WARNING "cciss: cmd %p has "
2384                                "protocol error \n", cmd);
2385                         status = 0;
2386                         break;
2387                 case CMD_HARDWARE_ERR:
2388                         printk(KERN_WARNING "cciss: cmd %p had "
2389                                " hardware error\n", cmd);
2390                         status = 0;
2391                         break;
2392                 case CMD_CONNECTION_LOST:
2393                         printk(KERN_WARNING "cciss: cmd %p had "
2394                                "connection lost\n", cmd);
2395                         status = 0;
2396                         break;
2397                 case CMD_ABORTED:
2398                         printk(KERN_WARNING "cciss: cmd %p was "
2399                                "aborted\n", cmd);
2400                         status = 0;
2401                         break;
2402                 case CMD_ABORT_FAILED:
2403                         printk(KERN_WARNING "cciss: cmd %p reports "
2404                                "abort failed\n", cmd);
2405                         status = 0;
2406                         break;
2407                 case CMD_UNSOLICITED_ABORT:
2408                         printk(KERN_WARNING "cciss%d: unsolicited "
2409                                "abort %p\n", h->ctlr, cmd);
2410                         if (cmd->retry_count < MAX_CMD_RETRIES) {
2411                                 retry_cmd = 1;
2412                                 printk(KERN_WARNING
2413                                        "cciss%d: retrying %p\n", h->ctlr, cmd);
2414                                 cmd->retry_count++;
2415                         } else
2416                                 printk(KERN_WARNING
2417                                        "cciss%d: %p retried too "
2418                                        "many times\n", h->ctlr, cmd);
2419                         status = 0;
2420                         break;
2421                 case CMD_TIMEOUT:
2422                         printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2423                         status = 0;
2424                         break;
2425                 default:
2426                         printk(KERN_WARNING "cciss: cmd %p returned "
2427                                "unknown status %x\n", cmd,
2428                                cmd->err_info->CommandStatus);
2429                         status = 0;
2430                 }
2431         }
2432         /* We need to return this command */
2433         if (retry_cmd) {
2434                 resend_cciss_cmd(h, cmd);
2435                 return;
2436         }
2437
2438         cmd->rq->completion_data = cmd;
2439         cmd->rq->errors = status;
2440         blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
2441         blk_complete_request(cmd->rq);
2442 }
2443
2444 /*
2445  * Get a request and submit it to the controller.
2446  */
2447 static void do_cciss_request(request_queue_t *q)
2448 {
2449         ctlr_info_t *h = q->queuedata;
2450         CommandList_struct *c;
2451         sector_t start_blk;
2452         int seg;
2453         struct request *creq;
2454         u64bit temp64;
2455         struct scatterlist tmp_sg[MAXSGENTRIES];
2456         drive_info_struct *drv;
2457         int i, dir;
2458
2459         /* We call start_io here in case there is a command waiting on the
2460          * queue that has not been sent.
2461          */
2462         if (blk_queue_plugged(q))
2463                 goto startio;
2464
2465       queue:
2466         creq = elv_next_request(q);
2467         if (!creq)
2468                 goto startio;
2469
2470         BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2471
2472         if ((c = cmd_alloc(h, 1)) == NULL)
2473                 goto full;
2474
2475         blkdev_dequeue_request(creq);
2476
2477         spin_unlock_irq(q->queue_lock);
2478
2479         c->cmd_type = CMD_RWREQ;
2480         c->rq = creq;
2481
2482         /* fill in the request */
2483         drv = creq->rq_disk->private_data;
2484         c->Header.ReplyQueue = 0;       // unused in simple mode
2485         /* got command from pool, so use the command block index instead */
2486         /* for direct lookups. */
2487         /* The first 2 bits are reserved for controller error reporting. */
2488         c->Header.Tag.lower = (c->cmdindex << 3);
2489         c->Header.Tag.lower |= 0x04;    /* flag for direct lookup. */
2490         c->Header.LUN.LogDev.VolId = drv->LunID;
2491         c->Header.LUN.LogDev.Mode = 1;
2492         c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2493         c->Request.Type.Type = TYPE_CMD;        // It is a command.
2494         c->Request.Type.Attribute = ATTR_SIMPLE;
2495         c->Request.Type.Direction =
2496             (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
2497         c->Request.Timeout = 0; // Don't time out
2498         c->Request.CDB[0] =
2499             (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2500         start_blk = creq->sector;
2501 #ifdef CCISS_DEBUG
2502         printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2503                (int)creq->nr_sectors);
2504 #endif                          /* CCISS_DEBUG */
2505
2506         seg = blk_rq_map_sg(q, creq, tmp_sg);
2507
2508         /* get the DMA records for the setup */
2509         if (c->Request.Type.Direction == XFER_READ)
2510                 dir = PCI_DMA_FROMDEVICE;
2511         else
2512                 dir = PCI_DMA_TODEVICE;
2513
2514         for (i = 0; i < seg; i++) {
2515                 c->SG[i].Len = tmp_sg[i].length;
2516                 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2517                                                   tmp_sg[i].offset,
2518                                                   tmp_sg[i].length, dir);
2519                 c->SG[i].Addr.lower = temp64.val32.lower;
2520                 c->SG[i].Addr.upper = temp64.val32.upper;
2521                 c->SG[i].Ext = 0;       // we are not chaining
2522         }
2523         /* track how many SG entries we are using */
2524         if (seg > h->maxSG)
2525                 h->maxSG = seg;
2526
2527 #ifdef CCISS_DEBUG
2528         printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2529                creq->nr_sectors, seg);
2530 #endif                          /* CCISS_DEBUG */
2531
2532         c->Header.SGList = c->Header.SGTotal = seg;
2533         if(h->cciss_read == CCISS_READ_10) {
2534                 c->Request.CDB[1] = 0;
2535                 c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
2536                 c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2537                 c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2538                 c->Request.CDB[5] = start_blk & 0xff;
2539                 c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
2540                 c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2541                 c->Request.CDB[8] = creq->nr_sectors & 0xff;
2542                 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2543         } else {
2544                 c->Request.CDBLen = 16;
2545                 c->Request.CDB[1]= 0;
2546                 c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
2547                 c->Request.CDB[3]= (start_blk >> 48) & 0xff;
2548                 c->Request.CDB[4]= (start_blk >> 40) & 0xff;
2549                 c->Request.CDB[5]= (start_blk >> 32) & 0xff;
2550                 c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2551                 c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2552                 c->Request.CDB[8]= (start_blk >>  8) & 0xff;
2553                 c->Request.CDB[9]= start_blk & 0xff;
2554                 c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
2555                 c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
2556                 c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
2557                 c->Request.CDB[13]= creq->nr_sectors & 0xff;
2558                 c->Request.CDB[14] = c->Request.CDB[15] = 0;
2559         }
2560
2561         spin_lock_irq(q->queue_lock);
2562
2563         addQ(&(h->reqQ), c);
2564         h->Qdepth++;
2565         if (h->Qdepth > h->maxQsinceinit)
2566                 h->maxQsinceinit = h->Qdepth;
2567
2568         goto queue;
2569 full:
2570         blk_stop_queue(q);
2571 startio:
2572         /* We will already have the driver lock here so not need
2573          * to lock it.
2574          */
2575         start_io(h);
2576 }
2577
2578 static inline unsigned long get_next_completion(ctlr_info_t *h)
2579 {
2580 #ifdef CONFIG_CISS_SCSI_TAPE
2581         /* Any rejects from sendcmd() lying around? Process them first */
2582         if (h->scsi_rejects.ncompletions == 0)
2583                 return h->access.command_completed(h);
2584         else {
2585                 struct sendcmd_reject_list *srl;
2586                 int n;
2587                 srl = &h->scsi_rejects;
2588                 n = --srl->ncompletions;
2589                 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2590                 printk("p");
2591                 return srl->complete[n];
2592         }
2593 #else
2594         return h->access.command_completed(h);
2595 #endif
2596 }
2597
2598 static inline int interrupt_pending(ctlr_info_t *h)
2599 {
2600 #ifdef CONFIG_CISS_SCSI_TAPE
2601         return (h->access.intr_pending(h)
2602                 || (h->scsi_rejects.ncompletions > 0));
2603 #else
2604         return h->access.intr_pending(h);
2605 #endif
2606 }
2607
2608 static inline long interrupt_not_for_us(ctlr_info_t *h)
2609 {
2610 #ifdef CONFIG_CISS_SCSI_TAPE
2611         return (((h->access.intr_pending(h) == 0) ||
2612                  (h->interrupts_enabled == 0))
2613                 && (h->scsi_rejects.ncompletions == 0));
2614 #else
2615         return (((h->access.intr_pending(h) == 0) ||
2616                  (h->interrupts_enabled == 0)));
2617 #endif
2618 }
2619
2620 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
2621 {
2622         ctlr_info_t *h = dev_id;
2623         CommandList_struct *c;
2624         unsigned long flags;
2625         __u32 a, a1, a2;
2626
2627         if (interrupt_not_for_us(h))
2628                 return IRQ_NONE;
2629         /*
2630          * If there are completed commands in the completion queue,
2631          * we had better do something about it.
2632          */
2633         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2634         while (interrupt_pending(h)) {
2635                 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
2636                         a1 = a;
2637                         if ((a & 0x04)) {
2638                                 a2 = (a >> 3);
2639                                 if (a2 >= h->nr_cmds) {
2640                                         printk(KERN_WARNING
2641                                                "cciss: controller cciss%d failed, stopping.\n",
2642                                                h->ctlr);
2643                                         fail_all_cmds(h->ctlr);
2644                                         return IRQ_HANDLED;
2645                                 }
2646
2647                                 c = h->cmd_pool + a2;
2648                                 a = c->busaddr;
2649
2650                         } else {
2651                                 a &= ~3;
2652                                 if ((c = h->cmpQ) == NULL) {
2653                                         printk(KERN_WARNING
2654                                                "cciss: Completion of %08x ignored\n",
2655                                                a1);
2656                                         continue;
2657                                 }
2658                                 while (c->busaddr != a) {
2659                                         c = c->next;
2660                                         if (c == h->cmpQ)
2661                                                 break;
2662                                 }
2663                         }
2664                         /*
2665                          * If we've found the command, take it off the
2666                          * completion Q and free it
2667                          */
2668                         if (c->busaddr == a) {
2669                                 removeQ(&h->cmpQ, c);
2670                                 if (c->cmd_type == CMD_RWREQ) {
2671                                         complete_command(h, c, 0);
2672                                 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2673                                         complete(c->waiting);
2674                                 }
2675 #                               ifdef CONFIG_CISS_SCSI_TAPE
2676                                 else if (c->cmd_type == CMD_SCSI)
2677                                         complete_scsi_command(c, 0, a1);
2678 #                               endif
2679                                 continue;
2680                         }
2681                 }
2682         }
2683
2684         spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2685         return IRQ_HANDLED;
2686 }
2687
2688 /*
2689  *  We cannot read the structure directly, for portability we must use
2690  *   the io functions.
2691  *   This is for debug only.
2692  */
2693 #ifdef CCISS_DEBUG
2694 static void print_cfg_table(CfgTable_struct *tb)
2695 {
2696         int i;
2697         char temp_name[17];
2698
2699         printk("Controller Configuration information\n");
2700         printk("------------------------------------\n");
2701         for (i = 0; i < 4; i++)
2702                 temp_name[i] = readb(&(tb->Signature[i]));
2703         temp_name[4] = '\0';
2704         printk("   Signature = %s\n", temp_name);
2705         printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));
2706         printk("   Transport methods supported = 0x%x\n",
2707                readl(&(tb->TransportSupport)));
2708         printk("   Transport methods active = 0x%x\n",
2709                readl(&(tb->TransportActive)));
2710         printk("   Requested transport Method = 0x%x\n",
2711                readl(&(tb->HostWrite.TransportRequest)));
2712         printk("   Coalesce Interrupt Delay = 0x%x\n",
2713                readl(&(tb->HostWrite.CoalIntDelay)));
2714         printk("   Coalesce Interrupt Count = 0x%x\n",
2715                readl(&(tb->HostWrite.CoalIntCount)));
2716         printk("   Max outstanding commands = 0x%d\n",
2717                readl(&(tb->CmdsOutMax)));
2718         printk("   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
2719         for (i = 0; i < 16; i++)
2720                 temp_name[i] = readb(&(tb->ServerName[i]));
2721         temp_name[16] = '\0';
2722         printk("   Server Name = %s\n", temp_name);
2723         printk("   Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
2724 }
2725 #endif                          /* CCISS_DEBUG */
2726
2727 static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
2728 {
2729         int i, offset, mem_type, bar_type;
2730         if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2731                 return 0;
2732         offset = 0;
2733         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
2734                 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
2735                 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2736                         offset += 4;
2737                 else {
2738                         mem_type = pci_resource_flags(pdev, i) &
2739                             PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2740                         switch (mem_type) {
2741                         case PCI_BASE_ADDRESS_MEM_TYPE_32:
2742                         case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2743                                 offset += 4;    /* 32 bit */
2744                                 break;
2745                         case PCI_BASE_ADDRESS_MEM_TYPE_64:
2746                                 offset += 8;
2747                                 break;
2748                         default:        /* reserved in PCI 2.2 */
2749                                 printk(KERN_WARNING
2750                                        "Base address is invalid\n");
2751                                 return -1;
2752                                 break;
2753                         }
2754                 }
2755                 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2756                         return i + 1;
2757         }
2758         return -1;
2759 }
2760
2761 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
2762  * controllers that are capable. If not, we use IO-APIC mode.
2763  */
2764
2765 static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
2766                                            struct pci_dev *pdev, __u32 board_id)
2767 {
2768 #ifdef CONFIG_PCI_MSI
2769         int err;
2770         struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
2771         {0, 2}, {0, 3}
2772         };
2773
2774         /* Some boards advertise MSI but don't really support it */
2775         if ((board_id == 0x40700E11) ||
2776             (board_id == 0x40800E11) ||
2777             (board_id == 0x40820E11) || (board_id == 0x40830E11))
2778                 goto default_int_mode;
2779
2780         if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
2781                 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
2782                 if (!err) {
2783                         c->intr[0] = cciss_msix_entries[0].vector;
2784                         c->intr[1] = cciss_msix_entries[1].vector;
2785                         c->intr[2] = cciss_msix_entries[2].vector;
2786                         c->intr[3] = cciss_msix_entries[3].vector;
2787                         c->msix_vector = 1;
2788                         return;
2789                 }
2790                 if (err > 0) {
2791                         printk(KERN_WARNING "cciss: only %d MSI-X vectors "
2792                                "available\n", err);
2793                         goto default_int_mode;
2794                 } else {
2795                         printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
2796                                err);
2797                         goto default_int_mode;
2798                 }
2799         }
2800         if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
2801                 if (!pci_enable_msi(pdev)) {
2802                         c->msi_vector = 1;
2803                 } else {
2804                         printk(KERN_WARNING "cciss: MSI init failed\n");
2805                 }
2806         }
2807 default_int_mode:
2808 #endif                          /* CONFIG_PCI_MSI */
2809         /* if we get here we're going to use the default interrupt mode */
2810         c->intr[SIMPLE_MODE_INT] = pdev->irq;
2811         return;
2812 }
2813
2814 static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2815 {
2816         ushort subsystem_vendor_id, subsystem_device_id, command;
2817         __u32 board_id, scratchpad = 0;
2818         __u64 cfg_offset;
2819         __u32 cfg_base_addr;
2820         __u64 cfg_base_addr_index;
2821         int i, err;
2822
2823         /* check to see if controller has been disabled */
2824         /* BEFORE trying to enable it */
2825         (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
2826         if (!(command & 0x02)) {
2827                 printk(KERN_WARNING
2828                        "cciss: controller appears to be disabled\n");
2829                 return -ENODEV;
2830         }
2831
2832         err = pci_enable_device(pdev);
2833         if (err) {
2834                 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2835                 return err;
2836         }
2837
2838         err = pci_request_regions(pdev, "cciss");
2839         if (err) {
2840                 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
2841                        "aborting\n");
2842                 return err;
2843         }
2844
2845         subsystem_vendor_id = pdev->subsystem_vendor;
2846         subsystem_device_id = pdev->subsystem_device;
2847         board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2848                     subsystem_vendor_id);
2849
2850 #ifdef CCISS_DEBUG
2851         printk("command = %x\n", command);
2852         printk("irq = %x\n", pdev->irq);
2853         printk("board_id = %x\n", board_id);
2854 #endif                          /* CCISS_DEBUG */
2855
2856 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
2857  * else we use the IO-APIC interrupt assigned to us by system ROM.
2858  */
2859         cciss_interrupt_mode(c, pdev, board_id);
2860
2861         /*
2862          * Memory base addr is first addr , the second points to the config
2863          *   table
2864          */
2865
2866         c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2867 #ifdef CCISS_DEBUG
2868         printk("address 0 = %x\n", c->paddr);
2869 #endif                          /* CCISS_DEBUG */
2870         c->vaddr = remap_pci_mem(c->paddr, 0x250);
2871
2872         /* Wait for the board to become ready.  (PCI hotplug needs this.)
2873          * We poll for up to 120 secs, once per 100ms. */
2874         for (i = 0; i < 1200; i++) {
2875                 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2876                 if (scratchpad == CCISS_FIRMWARE_READY)
2877                         break;
2878                 set_current_state(TASK_INTERRUPTIBLE);
2879                 schedule_timeout(HZ / 10);      /* wait 100ms */
2880         }
2881         if (scratchpad != CCISS_FIRMWARE_READY) {
2882                 printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");
2883                 err = -ENODEV;
2884                 goto err_out_free_res;
2885         }
2886
2887         /* get the address index number */
2888         cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2889         cfg_base_addr &= (__u32) 0x0000ffff;
2890 #ifdef CCISS_DEBUG
2891         printk("cfg base address = %x\n", cfg_base_addr);
2892 #endif                          /* CCISS_DEBUG */
2893         cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
2894 #ifdef CCISS_DEBUG
2895         printk("cfg base address index = %x\n", cfg_base_addr_index);
2896 #endif                          /* CCISS_DEBUG */
2897         if (cfg_base_addr_index == -1) {
2898                 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2899                 err = -ENODEV;
2900                 goto err_out_free_res;
2901         }
2902
2903         cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2904 #ifdef CCISS_DEBUG
2905         printk("cfg offset = %x\n", cfg_offset);
2906 #endif                          /* CCISS_DEBUG */
2907         c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2908                                                        cfg_base_addr_index) +
2909                                     cfg_offset, sizeof(CfgTable_struct));
2910         c->board_id = board_id;
2911
2912 #ifdef CCISS_DEBUG
2913         print_cfg_table(c->cfgtable);
2914 #endif                          /* CCISS_DEBUG */
2915
2916         for (i = 0; i < ARRAY_SIZE(products); i++) {
2917                 if (board_id == products[i].board_id) {
2918                         c->product_name = products[i].product_name;
2919                         c->access = *(products[i].access);
2920                         c->nr_cmds = products[i].nr_cmds;
2921                         break;
2922                 }
2923         }
2924         if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
2925             (readb(&c->cfgtable->Signature[1]) != 'I') ||
2926             (readb(&c->cfgtable->Signature[2]) != 'S') ||
2927             (readb(&c->cfgtable->Signature[3]) != 'S')) {
2928                 printk("Does not appear to be a valid CISS config table\n");
2929                 err = -ENODEV;
2930                 goto err_out_free_res;
2931         }
2932         /* We didn't find the controller in our list. We know the
2933          * signature is valid. If it's an HP device let's try to
2934          * bind to the device and fire it up. Otherwise we bail.
2935          */
2936         if (i == ARRAY_SIZE(products)) {
2937                 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
2938                         c->product_name = products[i-1].product_name;
2939                         c->access = *(products[i-1].access);
2940                         c->nr_cmds = products[i-1].nr_cmds;
2941                         printk(KERN_WARNING "cciss: This is an unknown "
2942                                 "Smart Array controller.\n"
2943                                 "cciss: Please update to the latest driver "
2944                                 "available from www.hp.com.\n");
2945                 } else {
2946                         printk(KERN_WARNING "cciss: Sorry, I don't know how"
2947                                 " to access the Smart Array controller %08lx\n"
2948                                         , (unsigned long)board_id);
2949                         err = -ENODEV;
2950                         goto err_out_free_res;
2951                 }
2952         }
2953 #ifdef CONFIG_X86
2954         {
2955                 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2956                 __u32 prefetch;
2957                 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
2958                 prefetch |= 0x100;
2959                 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
2960         }
2961 #endif
2962
2963         /* Disabling DMA prefetch for the P600
2964          * An ASIC bug may result in a prefetch beyond
2965          * physical memory.
2966          */
2967         if(board_id == 0x3225103C) {
2968                 __u32 dma_prefetch;
2969                 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
2970                 dma_prefetch |= 0x8000;
2971                 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
2972         }
2973
2974 #ifdef CCISS_DEBUG
2975         printk("Trying to put board into Simple mode\n");
2976 #endif                          /* CCISS_DEBUG */
2977         c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
2978         /* Update the field, and then ring the doorbell */
2979         writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
2980         writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
2981
2982         /* under certain very rare conditions, this can take awhile.
2983          * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2984          * as we enter this code.) */
2985         for (i = 0; i < MAX_CONFIG_WAIT; i++) {
2986                 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
2987                         break;
2988                 /* delay and try again */
2989                 set_current_state(TASK_INTERRUPTIBLE);
2990                 schedule_timeout(10);
2991         }
2992
2993 #ifdef CCISS_DEBUG
2994         printk(KERN_DEBUG "I counter got to %d %x\n", i,
2995                readl(c->vaddr + SA5_DOORBELL));
2996 #endif                          /* CCISS_DEBUG */
2997 #ifdef CCISS_DEBUG
2998         print_cfg_table(c->cfgtable);
2999 #endif                          /* CCISS_DEBUG */
3000
3001         if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
3002                 printk(KERN_WARNING "cciss: unable to get board into"
3003                        " simple mode\n");
3004                 err = -ENODEV;
3005                 goto err_out_free_res;
3006         }
3007         return 0;
3008
3009 err_out_free_res:
3010         /*
3011          * Deliberately omit pci_disable_device(): it does something nasty to
3012          * Smart Array controllers that pci_enable_device does not undo
3013          */
3014         pci_release_regions(pdev);
3015         return err;
3016 }
3017
3018 /*
3019  * Gets information about the local volumes attached to the controller.
3020  */
3021 static void cciss_getgeometry(int cntl_num)
3022 {
3023         ReportLunData_struct *ld_buff;
3024         InquiryData_struct *inq_buff;
3025         int return_code;
3026         int i;
3027         int listlength = 0;
3028         __u32 lunid = 0;
3029         int block_size;
3030         sector_t total_size;
3031
3032         ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
3033         if (ld_buff == NULL) {
3034                 printk(KERN_ERR "cciss: out of memory\n");
3035                 return;
3036         }
3037         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
3038         if (inq_buff == NULL) {
3039                 printk(KERN_ERR "cciss: out of memory\n");
3040                 kfree(ld_buff);
3041                 return;
3042         }
3043         /* Get the firmware version */
3044         return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
3045                               sizeof(InquiryData_struct), 0, 0, 0, NULL,
3046                               TYPE_CMD);
3047         if (return_code == IO_OK) {
3048                 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
3049                 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
3050                 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
3051                 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
3052         } else {                /* send command failed */
3053
3054                 printk(KERN_WARNING "cciss: unable to determine firmware"
3055                        " version of controller\n");
3056         }
3057         /* Get the number of logical volumes */
3058         return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
3059                               sizeof(ReportLunData_struct), 0, 0, 0, NULL,
3060                               TYPE_CMD);
3061
3062         if (return_code == IO_OK) {
3063 #ifdef CCISS_DEBUG
3064                 printk("LUN Data\n--------------------------\n");
3065 #endif                          /* CCISS_DEBUG */
3066
3067                 listlength |=
3068                     (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
3069                 listlength |=
3070                     (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
3071                 listlength |=
3072                     (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
3073                 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
3074         } else {                /* reading number of logical volumes failed */
3075
3076                 printk(KERN_WARNING "cciss: report logical volume"
3077                        " command failed\n");
3078                 listlength = 0;
3079         }
3080         hba[cntl_num]->num_luns = listlength / 8;       // 8 bytes pre entry
3081         if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
3082                 printk(KERN_ERR
3083                        "ciss:  only %d number of logical volumes supported\n",
3084                        CISS_MAX_LUN);
3085                 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3086         }
3087 #ifdef CCISS_DEBUG
3088         printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
3089                ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
3090                ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
3091                hba[cntl_num]->num_luns);
3092 #endif                          /* CCISS_DEBUG */
3093
3094         hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
3095         for (i = 0; i < CISS_MAX_LUN; i++) {
3096                 if (i < hba[cntl_num]->num_luns) {
3097                         lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3098                             << 24;
3099                         lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3100                             << 16;
3101                         lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3102                             << 8;
3103                         lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3104
3105                         hba[cntl_num]->drv[i].LunID = lunid;
3106
3107 #ifdef CCISS_DEBUG
3108                         printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i,
3109                                ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3110                                ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3111                                hba[cntl_num]->drv[i].LunID);
3112 #endif                          /* CCISS_DEBUG */
3113
3114                 /* testing to see if 16-byte CDBs are already being used */
3115                 if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
3116                         cciss_read_capacity_16(cntl_num, i, 0,
3117                                             &total_size, &block_size);
3118                         goto geo_inq;
3119                 }
3120                 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
3121
3122                 /* total_size = last LBA + 1 */
3123                 if(total_size == (__u32) 0) {
3124                         cciss_read_capacity_16(cntl_num, i, 0,
3125                         &total_size, &block_size);
3126                         hba[cntl_num]->cciss_read = CCISS_READ_16;
3127                         hba[cntl_num]->cciss_write = CCISS_WRITE_16;
3128                 } else {
3129                         hba[cntl_num]->cciss_read = CCISS_READ_10;
3130                         hba[cntl_num]->cciss_write = CCISS_WRITE_10;
3131                 }
3132 geo_inq:
3133                         cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3134                                                block_size, inq_buff,
3135                                                &hba[cntl_num]->drv[i]);
3136                 } else {
3137                         /* initialize raid_level to indicate a free space */
3138                         hba[cntl_num]->drv[i].raid_level = -1;
3139                 }
3140         }
3141         kfree(ld_buff);
3142         kfree(inq_buff);
3143 }
3144
3145 /* Function to find the first free pointer into our hba[] array */
3146 /* Returns -1 if no free entries are left.  */
3147 static int alloc_cciss_hba(void)
3148 {
3149         int i;
3150
3151         for (i = 0; i < MAX_CTLR; i++) {
3152                 if (!hba[i]) {
3153                         ctlr_info_t *p;
3154                         p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3155                         if (!p)
3156                                 goto Enomem;
3157                         p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
3158                         if (!p->gendisk[0])
3159                                 goto Enomem;
3160                         hba[i] = p;
3161                         return i;
3162                 }
3163         }
3164         printk(KERN_WARNING "cciss: This driver supports a maximum"
3165                " of %d controllers.\n", MAX_CTLR);
3166         return -1;
3167 Enomem:
3168         printk(KERN_ERR "cciss: out of memory.\n");
3169         return -1;
3170 }
3171
3172 static void free_hba(int i)
3173 {
3174         ctlr_info_t *p = hba[i];
3175         int n;
3176
3177         hba[i] = NULL;
3178         for (n = 0; n < CISS_MAX_LUN; n++)
3179                 put_disk(p->gendisk[n]);
3180         kfree(p);
3181 }
3182
3183 /*
3184  *  This is it.  Find all the controllers and register them.  I really hate
3185  *  stealing all these major device numbers.
3186  *  returns the number of block devices registered.
3187  */
3188 static int __devinit cciss_init_one(struct pci_dev *pdev,
3189                                     const struct pci_device_id *ent)
3190 {
3191         int i;
3192         int j = 0;
3193         int rc;
3194         int dac;
3195
3196         i = alloc_cciss_hba();
3197         if (i < 0)
3198                 return -1;
3199
3200         hba[i]->busy_initializing = 1;
3201
3202         if (cciss_pci_init(hba[i], pdev) != 0)
3203                 goto clean1;
3204
3205         sprintf(hba[i]->devname, "cciss%d", i);
3206         hba[i]->ctlr = i;
3207         hba[i]->pdev = pdev;
3208
3209         /* configure PCI DMA stuff */
3210         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3211                 dac = 1;
3212         else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3213                 dac = 0;
3214         else {
3215                 printk(KERN_ERR "cciss: no suitable DMA available\n");
3216                 goto clean1;
3217         }
3218
3219         /*
3220          * register with the major number, or get a dynamic major number
3221          * by passing 0 as argument.  This is done for greater than
3222          * 8 controller support.
3223          */
3224         if (i < MAX_CTLR_ORIG)
3225                 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3226         rc = register_blkdev(hba[i]->major, hba[i]->devname);
3227         if (rc == -EBUSY || rc == -EINVAL) {
3228                 printk(KERN_ERR
3229                        "cciss:  Unable to get major number %d for %s "
3230                        "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3231                 goto clean1;
3232         } else {
3233                 if (i >= MAX_CTLR_ORIG)
3234                         hba[i]->major = rc;
3235         }
3236
3237         /* make sure the board interrupts are off */
3238         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3239         if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3240                         IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
3241                 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3242                        hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3243                 goto clean2;
3244         }
3245
3246         printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3247                hba[i]->devname, pdev->device, pci_name(pdev),
3248                hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3249
3250         hba[i]->cmd_pool_bits =
3251             kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
3252                       1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3253         hba[i]->cmd_pool = (CommandList_struct *)
3254             pci_alloc_consistent(hba[i]->pdev,
3255                     hba[i]->nr_cmds * sizeof(CommandList_struct),
3256                     &(hba[i]->cmd_pool_dhandle));
3257         hba[i]->errinfo_pool = (ErrorInfo_struct *)
3258             pci_alloc_consistent(hba[i]->pdev,
3259                     hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3260                     &(hba[i]->errinfo_pool_dhandle));
3261         if ((hba[i]->cmd_pool_bits == NULL)
3262             || (hba[i]->cmd_pool == NULL)
3263             || (hba[i]->errinfo_pool == NULL)) {
3264                 printk(KERN_ERR "cciss: out of memory");
3265                 goto clean4;
3266         }
3267 #ifdef CONFIG_CISS_SCSI_TAPE
3268         hba[i]->scsi_rejects.complete =
3269             kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3270                     (hba[i]->nr_cmds + 5), GFP_KERNEL);
3271         if (hba[i]->scsi_rejects.complete == NULL) {
3272                 printk(KERN_ERR "cciss: out of memory");
3273                 goto clean4;
3274         }
3275 #endif
3276         spin_lock_init(&hba[i]->lock);
3277
3278         /* Initialize the pdev driver private data.
3279            have it point to hba[i].  */
3280         pci_set_drvdata(pdev, hba[i]);
3281         /* command and error info recs zeroed out before
3282            they are used */
3283         memset(hba[i]->cmd_pool_bits, 0,
3284                ((hba[i]->nr_cmds + BITS_PER_LONG -
3285                  1) / BITS_PER_LONG) * sizeof(unsigned long));
3286
3287 #ifdef CCISS_DEBUG
3288         printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
3289 #endif                          /* CCISS_DEBUG */
3290
3291         cciss_getgeometry(i);
3292
3293         cciss_scsi_setup(i);
3294
3295         /* Turn the interrupts on so we can service requests */
3296         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3297
3298         cciss_procinit(i);
3299
3300         hba[i]->cciss_max_sectors = 2048;
3301
3302         hba[i]->busy_initializing = 0;
3303
3304         do {
3305                 drive_info_struct *drv = &(hba[i]->drv[j]);
3306                 struct gendisk *disk = hba[i]->gendisk[j];
3307                 request_queue_t *q;
3308
3309                 /* Check if the disk was allocated already */
3310                 if (!disk){
3311                         hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
3312                         disk = hba[i]->gendisk[j];
3313                 }
3314
3315                 /* Check that the disk was able to be allocated */
3316                 if (!disk) {
3317                         printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
3318                         goto clean4;
3319                 }
3320
3321                 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3322                 if (!q) {
3323                         printk(KERN_ERR
3324                                "cciss:  unable to allocate queue for disk %d\n",
3325                                j);
3326                         goto clean4;
3327                 }
3328                 drv->queue = q;
3329
3330                 q->backing_dev_info.ra_pages = READ_AHEAD;
3331                 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3332
3333                 /* This is a hardware imposed limit. */
3334                 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3335
3336                 /* This is a limit in the driver and could be eliminated. */
3337                 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3338
3339                 blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
3340
3341                 blk_queue_softirq_done(q, cciss_softirq_done);
3342
3343                 q->queuedata = hba[i];
3344                 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3345                 disk->major = hba[i]->major;
3346                 disk->first_minor = j << NWD_SHIFT;
3347                 disk->fops = &cciss_fops;
3348                 disk->queue = q;
3349                 disk->private_data = drv;
3350                 disk->driverfs_dev = &pdev->dev;
3351                 /* we must register the controller even if no disks exist */
3352                 /* this is for the online array utilities */
3353                 if (!drv->heads && j)
3354                         continue;
3355                 blk_queue_hardsect_size(q, drv->block_size);
3356                 set_capacity(disk, drv->nr_blocks);
3357                 add_disk(disk);
3358                 j++;
3359         } while (j <= hba[i]->highest_lun);
3360
3361         return 1;
3362
3363       clean4:
3364 #ifdef CONFIG_CISS_SCSI_TAPE
3365         kfree(hba[i]->scsi_rejects.complete);
3366 #endif
3367         kfree(hba[i]->cmd_pool_bits);
3368         if (hba[i]->cmd_pool)
3369                 pci_free_consistent(hba[i]->pdev,
3370                                     hba[i]->nr_cmds * sizeof(CommandList_struct),
3371                                     hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3372         if (hba[i]->errinfo_pool)
3373                 pci_free_consistent(hba[i]->pdev,
3374                                     hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3375                                     hba[i]->errinfo_pool,
3376                                     hba[i]->errinfo_pool_dhandle);
3377         free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3378       clean2:
3379         unregister_blkdev(hba[i]->major, hba[i]->devname);
3380       clean1:
3381         hba[i]->busy_initializing = 0;
3382         /* cleanup any queues that may have been initialized */
3383         for (j=0; j <= hba[i]->highest_lun; j++){
3384                 drive_info_struct *drv = &(hba[i]->drv[j]);
3385                 if (drv->queue)
3386                         blk_cleanup_queue(drv->queue);
3387         }
3388         /*
3389          * Deliberately omit pci_disable_device(): it does something nasty to
3390          * Smart Array controllers that pci_enable_device does not undo
3391          */
3392         pci_release_regions(pdev);
3393         pci_set_drvdata(pdev, NULL);
3394         free_hba(i);
3395         return -1;
3396 }
3397
3398 static void __devexit cciss_remove_one(struct pci_dev *pdev)
3399 {
3400         ctlr_info_t *tmp_ptr;
3401         int i, j;
3402         char flush_buf[4];
3403         int return_code;
3404
3405         if (pci_get_drvdata(pdev) == NULL) {
3406                 printk(KERN_ERR "cciss: Unable to remove device \n");
3407                 return;
3408         }
3409         tmp_ptr = pci_get_drvdata(pdev);
3410         i = tmp_ptr->ctlr;
3411         if (hba[i] == NULL) {
3412                 printk(KERN_ERR "cciss: device appears to "
3413                        "already be removed \n");
3414                 return;
3415         }
3416         /* Turn board interrupts off  and send the flush cache command */
3417         /* sendcmd will turn off interrupt, and send the flush...
3418          * To write all data in the battery backed cache to disks */
3419         memset(flush_buf, 0, 4);
3420         return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3421                               TYPE_CMD);
3422         if (return_code != IO_OK) {
3423                 printk(KERN_WARNING "Error Flushing cache on controller %d\n",
3424                        i);
3425         }
3426         free_irq(hba[i]->intr[2], hba[i]);
3427
3428 #ifdef CONFIG_PCI_MSI
3429         if (hba[i]->msix_vector)
3430                 pci_disable_msix(hba[i]->pdev);
3431         else if (hba[i]->msi_vector)
3432                 pci_disable_msi(hba[i]->pdev);
3433 #endif                          /* CONFIG_PCI_MSI */
3434
3435         iounmap(hba[i]->vaddr);
3436         cciss_unregister_scsi(i);       /* unhook from SCSI subsystem */
3437         unregister_blkdev(hba[i]->major, hba[i]->devname);
3438         remove_proc_entry(hba[i]->devname, proc_cciss);
3439
3440         /* remove it from the disk list */
3441         for (j = 0; j < CISS_MAX_LUN; j++) {
3442                 struct gendisk *disk = hba[i]->gendisk[j];
3443                 if (disk) {
3444                         request_queue_t *q = disk->queue;
3445
3446                         if (disk->flags & GENHD_FL_UP)
3447                                 del_gendisk(disk);
3448                         if (q)
3449                                 blk_cleanup_queue(q);
3450                 }
3451         }
3452
3453         pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
3454                             hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3455         pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3456                             hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3457         kfree(hba[i]->cmd_pool_bits);
3458 #ifdef CONFIG_CISS_SCSI_TAPE
3459         kfree(hba[i]->scsi_rejects.complete);
3460 #endif
3461         /*
3462          * Deliberately omit pci_disable_device(): it does something nasty to
3463          * Smart Array controllers that pci_enable_device does not undo
3464          */
3465         pci_release_regions(pdev);
3466         pci_set_drvdata(pdev, NULL);
3467         free_hba(i);
3468 }
3469
3470 static struct pci_driver cciss_pci_driver = {
3471         .name = "cciss",
3472         .probe = cciss_init_one,
3473         .remove = __devexit_p(cciss_remove_one),
3474         .id_table = cciss_pci_device_id,        /* id_table */
3475 };
3476
3477 /*
3478  *  This is it.  Register the PCI driver information for the cards we control
3479  *  the OS will call our registered routines when it finds one of our cards.
3480  */
3481 static int __init cciss_init(void)
3482 {
3483         printk(KERN_INFO DRIVER_NAME "\n");
3484
3485         /* Register for our PCI devices */
3486         return pci_register_driver(&cciss_pci_driver);
3487 }
3488
3489 static void __exit cciss_cleanup(void)
3490 {
3491         int i;
3492
3493         pci_unregister_driver(&cciss_pci_driver);
3494         /* double check that all controller entrys have been removed */
3495         for (i = 0; i < MAX_CTLR; i++) {
3496                 if (hba[i] != NULL) {
3497                         printk(KERN_WARNING "cciss: had to remove"
3498                                " controller %d\n", i);
3499                         cciss_remove_one(hba[i]->pdev);
3500                 }
3501         }
3502         remove_proc_entry("cciss", proc_root_driver);
3503 }
3504
3505 static void fail_all_cmds(unsigned long ctlr)
3506 {
3507         /* If we get here, the board is apparently dead. */
3508         ctlr_info_t *h = hba[ctlr];
3509         CommandList_struct *c;
3510         unsigned long flags;
3511
3512         printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3513         h->alive = 0;           /* the controller apparently died... */
3514
3515         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3516
3517         pci_disable_device(h->pdev);    /* Make sure it is really dead. */
3518
3519         /* move everything off the request queue onto the completed queue */
3520         while ((c = h->reqQ) != NULL) {
3521                 removeQ(&(h->reqQ), c);
3522                 h->Qdepth--;
3523                 addQ(&(h->cmpQ), c);
3524         }
3525
3526         /* Now, fail everything on the completed queue with a HW error */
3527         while ((c = h->cmpQ) != NULL) {
3528                 removeQ(&h->cmpQ, c);
3529                 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3530                 if (c->cmd_type == CMD_RWREQ) {
3531                         complete_command(h, c, 0);
3532                 } else if (c->cmd_type == CMD_IOCTL_PEND)
3533                         complete(c->waiting);
3534 #ifdef CONFIG_CISS_SCSI_TAPE
3535                 else if (c->cmd_type == CMD_SCSI)
3536                         complete_scsi_command(c, 0, 0);
3537 #endif
3538         }
3539         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3540         return;
3541 }
3542
3543 module_init(cciss_init);
3544 module_exit(cciss_cleanup);