drivers/block/cciss.c

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