drivers/block/cciss.c

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