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