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