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