fedora core 6 1.2949 + vserver 2.2.0

[linux-2.6.git] / drivers / block / cciss.c

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 93e23d6..66fe4c0 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -20,7 +20,6 @@
  *
  */
 
  *
  */
 

-#include <linux/config.h>      /* CONFIG_PROC_FS */

 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/types.h>


@@ -34,10 +33,11 @@
 #include <linux/blkpg.h>
 #include <linux/timer.h>
 #include <linux/proc_fs.h>
 #include <linux/blkpg.h>
 #include <linux/timer.h>
 #include <linux/proc_fs.h>

-#include <linux/init.h> 
+#include <linux/init.h>

 #include <linux/hdreg.h>
 #include <linux/spinlock.h>
 #include <linux/compat.h>
 #include <linux/hdreg.h>
 #include <linux/spinlock.h>
 #include <linux/compat.h>

+#include <linux/blktrace_api.h>

 #include <asm/uaccess.h>
 #include <asm/io.h>
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
 


@@ -47,15 +47,17 @@
 #include <linux/completion.h>
 
 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
 #include <linux/completion.h>
 
 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))

-#define DRIVER_NAME "HP CISS Driver (v 2.6.10)"
-#define DRIVER_VERSION CCISS_DRIVER_VERSION(2,6,10)
+#define DRIVER_NAME "HP CISS Driver (v 3.6.14)"
+#define DRIVER_VERSION CCISS_DRIVER_VERSION(3,6,14)

 
 /* Embedded module documentation macros - see modules.h */
 MODULE_AUTHOR("Hewlett-Packard Company");
 
 /* Embedded module documentation macros - see modules.h */
 MODULE_AUTHOR("Hewlett-Packard Company");

-MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 2.6.10");
+MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 3.6.14");

 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"

-                       " SA6i P600 P800 P400 P400i E200 E200i");
+                       " SA6i P600 P800 P400 P400i E200 E200i E500");
+MODULE_VERSION("3.6.14");

 MODULE_LICENSE("GPL");
 MODULE_LICENSE("GPL");

+MODULE_VERSION("2.6.8");

 
 #include "cciss_cmd.h"
 #include "cciss.h"
 
 #include "cciss_cmd.h"
 #include "cciss.h"


@@ -63,143 +65,133 @@ MODULE_LICENSE("GPL");
 
 /* define the PCI info for the cards we can control */
 static const struct pci_device_id cciss_pci_device_id[] = {
 
 /* define the PCI info for the cards we can control */
 static const struct pci_device_id cciss_pci_device_id[] = {

-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
-                       0x0E11, 0x4070, 0, 0, 0},
-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
-                        0x0E11, 0x4080, 0, 0, 0},
-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
-                        0x0E11, 0x4082, 0, 0, 0},
-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
-                        0x0E11, 0x4083, 0, 0, 0},
-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-               0x0E11, 0x409A, 0, 0, 0},
-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-               0x0E11, 0x409B, 0, 0, 0},
-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-               0x0E11, 0x409C, 0, 0, 0},
-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-               0x0E11, 0x409D, 0, 0, 0},
-       { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-               0x0E11, 0x4091, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA,
-               0x103C, 0x3225, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
-               0x103c, 0x3223, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
-               0x103c, 0x3234, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
-               0x103c, 0x3235, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-               0x103c, 0x3211, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-               0x103c, 0x3212, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-               0x103c, 0x3213, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-               0x103c, 0x3214, 0, 0, 0},
-       { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-               0x103c, 0x3215, 0, 0, 0},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,  0x0E11, 0x4070},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
+       {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSA,     0x103C, 0x3225},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3223},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3234},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3235},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3211},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3212},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3213},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3214},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3215},
+       {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3237},
+       {PCI_VENDOR_ID_HP,     PCI_ANY_ID,      PCI_ANY_ID, PCI_ANY_ID,
+               PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},

        {0,}
 };
        {0,}
 };

-MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);

 
 

-#define NR_PRODUCTS ARRAY_SIZE(products)
+MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);

 
 /*  board_id = Subsystem Device ID & Vendor ID
  *  product = Marketing Name for the board
 
 /*  board_id = Subsystem Device ID & Vendor ID
  *  product = Marketing Name for the board

- *  access = Address of the struct of function pointers 
+ *  access = Address of the struct of function pointers
+ *  nr_cmds = Number of commands supported by controller

  */
 static struct board_type products[] = {
  */
 static struct board_type products[] = {

-       { 0x40700E11, "Smart Array 5300", &SA5_access },
-       { 0x40800E11, "Smart Array 5i", &SA5B_access},
-       { 0x40820E11, "Smart Array 532", &SA5B_access},
-       { 0x40830E11, "Smart Array 5312", &SA5B_access},
-       { 0x409A0E11, "Smart Array 641", &SA5_access},
-       { 0x409B0E11, "Smart Array 642", &SA5_access},
-       { 0x409C0E11, "Smart Array 6400", &SA5_access},
-       { 0x409D0E11, "Smart Array 6400 EM", &SA5_access},
-       { 0x40910E11, "Smart Array 6i", &SA5_access},
-       { 0x3225103C, "Smart Array P600", &SA5_access},
-       { 0x3223103C, "Smart Array P800", &SA5_access},
-       { 0x3234103C, "Smart Array P400", &SA5_access},
-       { 0x3235103C, "Smart Array P400i", &SA5_access},
-       { 0x3211103C, "Smart Array E200i", &SA5_access},
-       { 0x3212103C, "Smart Array E200", &SA5_access},
-       { 0x3213103C, "Smart Array E200i", &SA5_access},
-       { 0x3214103C, "Smart Array E200i", &SA5_access},
-       { 0x3215103C, "Smart Array E200i", &SA5_access},
+       {0x40700E11, "Smart Array 5300", &SA5_access, 512},
+       {0x40800E11, "Smart Array 5i", &SA5B_access, 512},
+       {0x40820E11, "Smart Array 532", &SA5B_access, 512},
+       {0x40830E11, "Smart Array 5312", &SA5B_access, 512},
+       {0x409A0E11, "Smart Array 641", &SA5_access, 512},
+       {0x409B0E11, "Smart Array 642", &SA5_access, 512},
+       {0x409C0E11, "Smart Array 6400", &SA5_access, 512},
+       {0x409D0E11, "Smart Array 6400 EM", &SA5_access, 512},
+       {0x40910E11, "Smart Array 6i", &SA5_access, 512},
+       {0x3225103C, "Smart Array P600", &SA5_access, 512},
+       {0x3223103C, "Smart Array P800", &SA5_access, 512},
+       {0x3234103C, "Smart Array P400", &SA5_access, 512},
+       {0x3235103C, "Smart Array P400i", &SA5_access, 512},
+       {0x3211103C, "Smart Array E200i", &SA5_access, 120},
+       {0x3212103C, "Smart Array E200", &SA5_access, 120},
+       {0x3213103C, "Smart Array E200i", &SA5_access, 120},
+       {0x3214103C, "Smart Array E200i", &SA5_access, 120},
+       {0x3215103C, "Smart Array E200i", &SA5_access, 120},
+       {0x3237103C, "Smart Array E500", &SA5_access, 512},
+       {0xFFFF103C, "Unknown Smart Array", &SA5_access, 120},

 };
 
 };
 

-/* How long to wait (in millesconds) for board to go into simple mode */
-#define MAX_CONFIG_WAIT 30000 
+/* How long to wait (in milliseconds) for board to go into simple mode */
+#define MAX_CONFIG_WAIT 30000

 #define MAX_IOCTL_CONFIG_WAIT 1000
 
 /*define how many times we will try a command because of bus resets */
 #define MAX_CMD_RETRIES 3
 
 #define READ_AHEAD      1024
 #define MAX_IOCTL_CONFIG_WAIT 1000
 
 /*define how many times we will try a command because of bus resets */
 #define MAX_CMD_RETRIES 3
 
 #define READ_AHEAD      1024

-#define NR_CMDS                 384 /* #commands that can be outstanding */

 #define MAX_CTLR       32
 
 /* Originally cciss driver only supports 8 major numbers */
 #define MAX_CTLR_ORIG  8
 
 #define MAX_CTLR       32
 
 /* Originally cciss driver only supports 8 major numbers */
 #define MAX_CTLR_ORIG  8
 

-

 static ctlr_info_t *hba[MAX_CTLR];
 
 static void do_cciss_request(request_queue_t *q);
 static ctlr_info_t *hba[MAX_CTLR];
 
 static void do_cciss_request(request_queue_t *q);

-static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t do_cciss_intr(int irq, void *dev_id);

 static int cciss_open(struct inode *inode, struct file *filep);
 static int cciss_release(struct inode *inode, struct file *filep);
 static int cciss_open(struct inode *inode, struct file *filep);
 static int cciss_release(struct inode *inode, struct file *filep);

-static int cciss_ioctl(struct inode *inode, struct file *filep, 
-               unsigned int cmd, unsigned long arg);
+static int cciss_ioctl(struct inode *inode, struct file *filep,
+                      unsigned int cmd, unsigned long arg);

 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 
 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 

-static int revalidate_allvol(ctlr_info_t *host);

 static int cciss_revalidate(struct gendisk *disk);
 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
 static int cciss_revalidate(struct gendisk *disk);
 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);

-static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, int clear_all);
+static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
+                          int clear_all);

 
 

-static void cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
-       int withirq, unsigned int *total_size, unsigned int *block_size);
+static void cciss_read_capacity(int ctlr, int logvol, int withirq,
+                       sector_t *total_size, unsigned int *block_size);
+static void cciss_read_capacity_16(int ctlr, int logvol, int withirq,
+                       sector_t *total_size, unsigned int *block_size);

 static void cciss_geometry_inquiry(int ctlr, int logvol,
 static void cciss_geometry_inquiry(int ctlr, int logvol,

-                       int withirq, unsigned int total_size,
+                       int withirq, sector_t total_size,

                        unsigned int block_size, InquiryData_struct *inq_buff,
                        unsigned int block_size, InquiryData_struct *inq_buff,

-                       drive_info_struct *drv);
+                                  drive_info_struct *drv);

 static void cciss_getgeometry(int cntl_num);
 static void cciss_getgeometry(int cntl_num);

-static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *, __u32);
-static void start_io( ctlr_info_t *h);
-static int sendcmd( __u8 cmd, int ctlr, void *buff, size_t size,
-       unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
-       unsigned char *scsi3addr, int cmd_type);
-static int sendcmd_withirq(__u8        cmd, int ctlr, void *buff, size_t size,
-       unsigned int use_unit_num, unsigned int log_unit, __u8  page_code,
-       int cmd_type);
+static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
+                                          __u32);
+static void start_io(ctlr_info_t *h);
+static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
+                  unsigned int use_unit_num, unsigned int log_unit,
+                  __u8 page_code, unsigned char *scsi3addr, int cmd_type);
+static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
+                          unsigned int use_unit_num, unsigned int log_unit,
+                          __u8 page_code, int cmd_type);

 
 static void fail_all_cmds(unsigned long ctlr);
 
 #ifdef CONFIG_PROC_FS
 
 static void fail_all_cmds(unsigned long ctlr);
 
 #ifdef CONFIG_PROC_FS

-static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
-               int length, int *eof, void *data);
+static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
+                              int length, int *eof, void *data);

 static void cciss_procinit(int i);
 #else
 static void cciss_procinit(int i);
 #else

-static void cciss_procinit(int i) {}
-#endif /* CONFIG_PROC_FS */
+static void cciss_procinit(int i)
+{
+}
+#endif                         /* CONFIG_PROC_FS */

 
 #ifdef CONFIG_COMPAT
 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
 #endif
 
 
 #ifdef CONFIG_COMPAT
 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
 #endif
 

-static struct block_device_operations cciss_fops  = {
-       .owner          = THIS_MODULE,
-       .open           = cciss_open, 
-       .release        = cciss_release,
-        .ioctl         = cciss_ioctl,
-        .getgeo                = cciss_getgeo,
+static struct block_device_operations cciss_fops = {
+       .owner = THIS_MODULE,
+       .open = cciss_open,
+       .release = cciss_release,
+       .ioctl = cciss_ioctl,
+       .getgeo = cciss_getgeo,

 #ifdef CONFIG_COMPAT
 #ifdef CONFIG_COMPAT

-       .compat_ioctl   = cciss_compat_ioctl,
+       .compat_ioctl = cciss_compat_ioctl,

 #endif
 #endif

-       .revalidate_disk= cciss_revalidate,
+       .revalidate_disk = cciss_revalidate,

 };
 
 /*
 };
 
 /*


@@ -207,32 +199,35 @@ static struct block_device_operations cciss_fops  = {
  */
 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
 {
  */
 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
 {

-        if (*Qptr == NULL) {
-                *Qptr = c;
-                c->next = c->prev = c;
-        } else {
-                c->prev = (*Qptr)->prev;
-                c->next = (*Qptr);
-                (*Qptr)->prev->next = c;
-                (*Qptr)->prev = c;
-        }
+       if (*Qptr == NULL) {
+               *Qptr = c;
+               c->next = c->prev = c;
+       } else {
+               c->prev = (*Qptr)->prev;
+               c->next = (*Qptr);
+               (*Qptr)->prev->next = c;
+               (*Qptr)->prev = c;
+       }

 }
 
 }
 

-static inline CommandList_struct *removeQ(CommandList_struct **Qptr, 
-                                               CommandList_struct *c)
+static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
+                                         CommandList_struct *c)

 {
 {

-        if (c && c->next != c) {
-                if (*Qptr == c) *Qptr = c->next;
-                c->prev->next = c->next;
-                c->next->prev = c->prev;
-        } else {
-                *Qptr = NULL;
-        }
-        return c;
+       if (c && c->next != c) {
+               if (*Qptr == c)
+                       *Qptr = c->next;
+               c->prev->next = c->next;
+               c->next->prev = c->prev;
+       } else {
+               *Qptr = NULL;
+       }
+       return c;

 }
 
 #include "cciss_scsi.c"                /* For SCSI tape support */
 
 }
 
 #include "cciss_scsi.c"                /* For SCSI tape support */
 

+#define RAID_UNKNOWN 6
+

 #ifdef CONFIG_PROC_FS
 
 /*
 #ifdef CONFIG_PROC_FS
 
 /*


@@ -240,24 +235,24 @@ static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
  */
 #define ENG_GIG 1000000000
 #define ENG_GIG_FACTOR (ENG_GIG/512)
  */
 #define ENG_GIG 1000000000
 #define ENG_GIG_FACTOR (ENG_GIG/512)

-#define RAID_UNKNOWN 6
-static const char *raid_label[] = {"0","4","1(1+0)","5","5+1","ADG",
-                                          "UNKNOWN"};
+static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
+       "UNKNOWN"
+};

 
 static struct proc_dir_entry *proc_cciss;
 
 
 static struct proc_dir_entry *proc_cciss;
 

-static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
-               int length, int *eof, void *data)
+static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
+                              int length, int *eof, void *data)

 {
 {

-        off_t pos = 0;
-        off_t len = 0;
-        int size, i, ctlr;
-        ctlr_info_t *h = (ctlr_info_t*)data;
-        drive_info_struct *drv;
+       off_t pos = 0;
+       off_t len = 0;
+       int size, i, ctlr;
+       ctlr_info_t *h = (ctlr_info_t *) data;
+       drive_info_struct *drv;

        unsigned long flags;
        unsigned long flags;

-        sector_t vol_sz, vol_sz_frac;
+       sector_t vol_sz, vol_sz_frac;

 
 

-        ctlr = h->ctlr;
+       ctlr = h->ctlr;

 
        /* prevent displaying bogus info during configuration
         * or deconfiguration of a logical volume
 
        /* prevent displaying bogus info during configuration
         * or deconfiguration of a logical volume


@@ -265,35 +260,38 @@ static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
        if (h->busy_configuring) {
                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
        if (h->busy_configuring) {
                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);

-       return -EBUSY;
+               return -EBUSY;

        }
        h->busy_configuring = 1;
        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 
        }
        h->busy_configuring = 1;
        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 

-        size = sprintf(buffer, "%s: HP %s Controller\n"
-               "Board ID: 0x%08lx\n"
-               "Firmware Version: %c%c%c%c\n"
-               "IRQ: %d\n"
-               "Logical drives: %d\n"
-               "Current Q depth: %d\n"
-               "Current # commands on controller: %d\n"
-               "Max Q depth since init: %d\n"
-               "Max # commands on controller since init: %d\n"
-               "Max SG entries since init: %d\n\n",
-                h->devname,
-                h->product_name,
-                (unsigned long)h->board_id,
-               h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
-                (unsigned int)h->intr[SIMPLE_MODE_INT],
-                h->num_luns, 
-               h->Qdepth, h->commands_outstanding,
-               h->maxQsinceinit, h->max_outstanding, h->maxSG);
-
-        pos += size; len += size;
+       size = sprintf(buffer, "%s: HP %s Controller\n"
+                      "Board ID: 0x%08lx\n"
+                      "Firmware Version: %c%c%c%c\n"
+                      "IRQ: %d\n"
+                      "Logical drives: %d\n"
+                      "Max sectors: %d\n"
+                      "Current Q depth: %d\n"
+                      "Current # commands on controller: %d\n"
+                      "Max Q depth since init: %d\n"
+                      "Max # commands on controller since init: %d\n"
+                      "Max SG entries since init: %d\n\n",
+                      h->devname,
+                      h->product_name,
+                      (unsigned long)h->board_id,
+                      h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
+                      h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
+                      h->num_luns,
+                      h->cciss_max_sectors,
+                      h->Qdepth, h->commands_outstanding,
+                      h->maxQsinceinit, h->max_outstanding, h->maxSG);
+
+       pos += size;
+       len += size;

        cciss_proc_tape_report(ctlr, buffer, &pos, &len);
        cciss_proc_tape_report(ctlr, buffer, &pos, &len);

-       for(i=0; i<=h->highest_lun; i++) {
+       for (i = 0; i <= h->highest_lun; i++) {

 
 

-                drv = &h->drv[i];
+               drv = &h->drv[i];

                if (drv->heads == 0)
                        continue;
 
                if (drv->heads == 0)
                        continue;
 


@@ -304,25 +302,26 @@ static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
 
                if (drv->raid_level > 5)
                        drv->raid_level = RAID_UNKNOWN;
 
                if (drv->raid_level > 5)
                        drv->raid_level = RAID_UNKNOWN;

-               size = sprintf(buffer+len, "cciss/c%dd%d:"
-                               "\t%4u.%02uGB\tRAID %s\n",
-                               ctlr, i, (int)vol_sz, (int)vol_sz_frac,
-                               raid_label[drv->raid_level]);
-                pos += size; len += size;
-        }
-
-        *eof = 1;
-        *start = buffer+offset;
-        len -= offset;
-        if (len>length)
-                len = length;
+               size = sprintf(buffer + len, "cciss/c%dd%d:"
+                              "\t%4u.%02uGB\tRAID %s\n",
+                              ctlr, i, (int)vol_sz, (int)vol_sz_frac,
+                              raid_label[drv->raid_level]);
+               pos += size;
+               len += size;
+       }
+
+       *eof = 1;
+       *start = buffer + offset;
+       len -= offset;
+       if (len > length)
+               len = length;

        h->busy_configuring = 0;
        h->busy_configuring = 0;

-        return len;
+       return len;

 }
 
 }
 

-static int 
-cciss_proc_write(struct file *file, const char __user *buffer, 
-                       unsigned long count, void *data)
+static int
+cciss_proc_write(struct file *file, const char __user *buffer,
+                unsigned long count, void *data)

 {
        unsigned char cmd[80];
        int len;
 {
        unsigned char cmd[80];
        int len;


@@ -331,20 +330,23 @@ cciss_proc_write(struct file *file, const char __user *buffer,
        int rc;
 #endif
 
        int rc;
 #endif
 

-       if (count > sizeof(cmd)-1) return -EINVAL;
-       if (copy_from_user(cmd, buffer, count)) return -EFAULT;
+       if (count > sizeof(cmd) - 1)
+               return -EINVAL;
+       if (copy_from_user(cmd, buffer, count))
+               return -EFAULT;

        cmd[count] = '\0';
        len = strlen(cmd);      // above 3 lines ensure safety
        cmd[count] = '\0';
        len = strlen(cmd);      // above 3 lines ensure safety

-       if (len && cmd[len-1] == '\n')
+       if (len && cmd[len - 1] == '\n')

                cmd[--len] = '\0';
 #      ifdef CONFIG_CISS_SCSI_TAPE
                cmd[--len] = '\0';
 #      ifdef CONFIG_CISS_SCSI_TAPE

-               if (strcmp("engage scsi", cmd)==0) {
-                       rc = cciss_engage_scsi(h->ctlr);
-                       if (rc != 0) return -rc;
-                       return count;
-               }
-               /* might be nice to have "disengage" too, but it's not 
-                  safely possible. (only 1 module use count, lock issues.) */
+       if (strcmp("engage scsi", cmd) == 0) {
+               rc = cciss_engage_scsi(h->ctlr);
+               if (rc != 0)
+                       return -rc;
+               return count;
+       }
+       /* might be nice to have "disengage" too, but it's not
+          safely possible. (only 1 module use count, lock issues.) */

 #      endif
        return -EINVAL;
 }
 #      endif
        return -EINVAL;
 }


@@ -357,116 +359,113 @@ static void __devinit cciss_procinit(int i)
 {
        struct proc_dir_entry *pde;
 
 {
        struct proc_dir_entry *pde;
 

-        if (proc_cciss == NULL) {
-                proc_cciss = proc_mkdir("cciss", proc_root_driver);
-                if (!proc_cciss) 
+       if (proc_cciss == NULL) {
+               proc_cciss = proc_mkdir("cciss", proc_root_driver);
+               if (!proc_cciss)

                        return;
                        return;

-        }
+       }

 
 

-       pde = create_proc_read_entry(hba[i]->devname, 
-               S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH, 
-               proc_cciss, cciss_proc_get_info, hba[i]);
+       pde = create_proc_read_entry(hba[i]->devname,
+                                    S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
+                                    proc_cciss, cciss_proc_get_info, hba[i]);

        pde->write_proc = cciss_proc_write;
 }
        pde->write_proc = cciss_proc_write;
 }

-#endif /* CONFIG_PROC_FS */
+#endif                         /* CONFIG_PROC_FS */

 
 

-/* 
- * For operations that cannot sleep, a command block is allocated at init, 
+/*
+ * For operations that cannot sleep, a command block is allocated at init,

  * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
  * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track

- * which ones are free or in use.  For operations that can wait for kmalloc 
- * to possible sleep, this routine can be called with get_from_pool set to 0. 
- * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was. 
- */ 
-static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
+ * which ones are free or in use.  For operations that can wait for kmalloc
+ * to possible sleep, this routine can be called with get_from_pool set to 0.
+ * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
+ */
+static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)

 {
        CommandList_struct *c;
 {
        CommandList_struct *c;

-       int i; 
+       int i;

        u64bit temp64;
        dma_addr_t cmd_dma_handle, err_dma_handle;
 
        u64bit temp64;
        dma_addr_t cmd_dma_handle, err_dma_handle;
 

-       if (!get_from_pool)
-       {
-               c = (CommandList_struct *) pci_alloc_consistent(
-                       h->pdev, sizeof(CommandList_struct), &cmd_dma_handle); 
-               if(c==NULL)
-                       return NULL;
+       if (!get_from_pool) {
+               c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
+                       sizeof(CommandList_struct), &cmd_dma_handle);
+               if (c == NULL)
+                       return NULL;

                memset(c, 0, sizeof(CommandList_struct));
 
                c->cmdindex = -1;
 
                memset(c, 0, sizeof(CommandList_struct));
 
                c->cmdindex = -1;
 

-               c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
-                                       h->pdev, sizeof(ErrorInfo_struct), 
-                                       &err_dma_handle);
-       
-               if (c->err_info == NULL)
-               {
-                       pci_free_consistent(h->pdev, 
+               c->err_info = (ErrorInfo_struct *)
+                   pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
+                           &err_dma_handle);
+
+               if (c->err_info == NULL) {
+                       pci_free_consistent(h->pdev,

                                sizeof(CommandList_struct), c, cmd_dma_handle);
                        return NULL;
                }
                memset(c->err_info, 0, sizeof(ErrorInfo_struct));
                                sizeof(CommandList_struct), c, cmd_dma_handle);
                        return NULL;
                }
                memset(c->err_info, 0, sizeof(ErrorInfo_struct));

-       } else /* get it out of the controllers pool */ 
-       {
-               do {
-                       i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
-                        if (i == NR_CMDS)
-                                return NULL;
-                } while(test_and_set_bit(i & (BITS_PER_LONG - 1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
+       } else {                /* get it out of the controllers pool */
+
+               do {
+                       i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
+                       if (i == h->nr_cmds)
+                               return NULL;
+               } while (test_and_set_bit
+                        (i & (BITS_PER_LONG - 1),
+                         h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);

 #ifdef CCISS_DEBUG
                printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
 #endif
 #ifdef CCISS_DEBUG
                printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
 #endif

-                c = h->cmd_pool + i;
+               c = h->cmd_pool + i;

                memset(c, 0, sizeof(CommandList_struct));
                memset(c, 0, sizeof(CommandList_struct));

-               cmd_dma_handle = h->cmd_pool_dhandle 
-                                       + i*sizeof(CommandList_struct);
+               cmd_dma_handle = h->cmd_pool_dhandle
+                   + i * sizeof(CommandList_struct);

                c->err_info = h->errinfo_pool + i;
                memset(c->err_info, 0, sizeof(ErrorInfo_struct));
                c->err_info = h->errinfo_pool + i;
                memset(c->err_info, 0, sizeof(ErrorInfo_struct));

-               err_dma_handle = h->errinfo_pool_dhandle 
-                                       + i*sizeof(ErrorInfo_struct);
-                h->nr_allocs++;
+               err_dma_handle = h->errinfo_pool_dhandle
+                   + i * sizeof(ErrorInfo_struct);
+               h->nr_allocs++;

 
                c->cmdindex = i;
 
                c->cmdindex = i;

-        }
+       }

 
        c->busaddr = (__u32) cmd_dma_handle;
 
        c->busaddr = (__u32) cmd_dma_handle;

-       temp64.val = (__u64) err_dma_handle;    
+       temp64.val = (__u64) err_dma_handle;

        c->ErrDesc.Addr.lower = temp64.val32.lower;
        c->ErrDesc.Addr.upper = temp64.val32.upper;
        c->ErrDesc.Len = sizeof(ErrorInfo_struct);
        c->ErrDesc.Addr.lower = temp64.val32.lower;
        c->ErrDesc.Addr.upper = temp64.val32.upper;
        c->ErrDesc.Len = sizeof(ErrorInfo_struct);

-       
-       c->ctlr = h->ctlr;
-        return c;
-

 
 

+       c->ctlr = h->ctlr;
+       return c;

 }
 
 }
 

-/* 
- * Frees a command block that was previously allocated with cmd_alloc(). 
+/*
+ * Frees a command block that was previously allocated with cmd_alloc().

  */
 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
 {
        int i;
        u64bit temp64;
 
  */
 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
 {
        int i;
        u64bit temp64;
 

-       if( !got_from_pool)
-       { 
+       if (!got_from_pool) {

                temp64.val32.lower = c->ErrDesc.Addr.lower;
                temp64.val32.upper = c->ErrDesc.Addr.upper;
                temp64.val32.lower = c->ErrDesc.Addr.lower;
                temp64.val32.upper = c->ErrDesc.Addr.upper;

-               pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct), 
-                       c->err_info, (dma_addr_t) temp64.val);
-               pci_free_consistent(h->pdev, sizeof(CommandList_struct), 
-                       c, (dma_addr_t) c->busaddr);
-       } else 
-       {
+               pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
+                                   c->err_info, (dma_addr_t) temp64.val);
+               pci_free_consistent(h->pdev, sizeof(CommandList_struct),
+                                   c, (dma_addr_t) c->busaddr);
+       } else {

                i = c - h->cmd_pool;
                i = c - h->cmd_pool;

-               clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
-                h->nr_frees++;
-        }
+               clear_bit(i & (BITS_PER_LONG - 1),
+                         h->cmd_pool_bits + (i / BITS_PER_LONG));
+               h->nr_frees++;
+       }

 }
 
 static inline ctlr_info_t *get_host(struct gendisk *disk)
 {
 }
 
 static inline ctlr_info_t *get_host(struct gendisk *disk)
 {

-       return disk->queue->queuedata; 
+       return disk->queue->queuedata;

 }
 
 static inline drive_info_struct *get_drv(struct gendisk *disk)
 }
 
 static inline drive_info_struct *get_drv(struct gendisk *disk)


@@ -484,7 +483,7 @@ static int cciss_open(struct inode *inode, struct file *filep)
 
 #ifdef CCISS_DEBUG
        printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
 
 #ifdef CCISS_DEBUG
        printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);

-#endif /* CCISS_DEBUG */ 
+#endif                         /* CCISS_DEBUG */

 
        if (host->busy_initializing || drv->busy_configuring)
                return -EBUSY;
 
        if (host->busy_initializing || drv->busy_configuring)
                return -EBUSY;


@@ -496,11 +495,11 @@ static int cciss_open(struct inode *inode, struct file *filep)
         * but I'm already using way to many device nodes to claim another one
         * for "raw controller".
         */
         * but I'm already using way to many device nodes to claim another one
         * for "raw controller".
         */

-       if (drv->nr_blocks == 0) {
-               if (iminor(inode) != 0) {       /* not node 0? */
+       if (drv->heads == 0) {
+               if (iminor(inode) != 0) {       /* not node 0? */

                        /* if not node 0 make sure it is a partition = 0 */
                        if (iminor(inode) & 0x0f) {
                        /* if not node 0 make sure it is a partition = 0 */
                        if (iminor(inode) & 0x0f) {

-                       return -ENXIO;
+                               return -ENXIO;

                                /* if it is, make sure we have a LUN ID */
                        } else if (drv->LunID == 0) {
                                return -ENXIO;
                                /* if it is, make sure we have a LUN ID */
                        } else if (drv->LunID == 0) {
                                return -ENXIO;


@@ -513,6 +512,7 @@ static int cciss_open(struct inode *inode, struct file *filep)
        host->usage_count++;
        return 0;
 }
        host->usage_count++;
        return 0;
 }

+

 /*
  * Close.  Sync first.
  */
 /*
  * Close.  Sync first.
  */


@@ -522,8 +522,9 @@ static int cciss_release(struct inode *inode, struct file *filep)
        drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
 
 #ifdef CCISS_DEBUG
        drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
 
 #ifdef CCISS_DEBUG

-       printk(KERN_DEBUG "cciss_release %s\n", inode->i_bdev->bd_disk->disk_name);
-#endif /* CCISS_DEBUG */
+       printk(KERN_DEBUG "cciss_release %s\n",
+              inode->i_bdev->bd_disk->disk_name);
+#endif                         /* CCISS_DEBUG */

 
        drv->usage_count--;
        host->usage_count--;
 
        drv->usage_count--;
        host->usage_count--;


@@ -536,13 +537,15 @@ static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 {
        int ret;
        lock_kernel();
 {
        int ret;
        lock_kernel();

-       ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
+       ret = cciss_ioctl(f->f_path.dentry->d_inode, f, cmd, arg);

        unlock_kernel();
        return ret;
 }
 
        unlock_kernel();
        return ret;
 }
 

-static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg);
-static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, unsigned long arg);
+static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
+                                 unsigned long arg);
+static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
+                                     unsigned long arg);

 
 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 {
 
 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 {


@@ -574,19 +577,26 @@ static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
        }
 }
 
        }
 }
 

-static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg)
+static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
+                                 unsigned long arg)

 {
        IOCTL32_Command_struct __user *arg32 =
 {
        IOCTL32_Command_struct __user *arg32 =

-               (IOCTL32_Command_struct __user *) arg;
+           (IOCTL32_Command_struct __user *) arg;

        IOCTL_Command_struct arg64;
        IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
        int err;
        u32 cp;
 
        err = 0;
        IOCTL_Command_struct arg64;
        IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
        int err;
        u32 cp;
 
        err = 0;

-       err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
-       err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
-       err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
+       err |=
+           copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
+                          sizeof(arg64.LUN_info));
+       err |=
+           copy_from_user(&arg64.Request, &arg32->Request,
+                          sizeof(arg64.Request));
+       err |=
+           copy_from_user(&arg64.error_info, &arg32->error_info,
+                          sizeof(arg64.error_info));

        err |= get_user(arg64.buf_size, &arg32->buf_size);
        err |= get_user(cp, &arg32->buf);
        arg64.buf = compat_ptr(cp);
        err |= get_user(arg64.buf_size, &arg32->buf_size);
        err |= get_user(cp, &arg32->buf);
        arg64.buf = compat_ptr(cp);


@@ -595,28 +605,38 @@ static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long ar
        if (err)
                return -EFAULT;
 
        if (err)
                return -EFAULT;
 

-       err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long) p);
+       err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p);

        if (err)
                return err;
        if (err)
                return err;

-       err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
+       err |=
+           copy_in_user(&arg32->error_info, &p->error_info,
+                        sizeof(arg32->error_info));

        if (err)
                return -EFAULT;
        return err;
 }
 
        if (err)
                return -EFAULT;
        return err;
 }
 

-static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned long arg)
+static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
+                                     unsigned long arg)

 {
        BIG_IOCTL32_Command_struct __user *arg32 =
 {
        BIG_IOCTL32_Command_struct __user *arg32 =

-               (BIG_IOCTL32_Command_struct __user *) arg;
+           (BIG_IOCTL32_Command_struct __user *) arg;

        BIG_IOCTL_Command_struct arg64;
        BIG_IOCTL_Command_struct arg64;

-       BIG_IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
+       BIG_IOCTL_Command_struct __user *p =
+           compat_alloc_user_space(sizeof(arg64));

        int err;
        u32 cp;
 
        err = 0;
        int err;
        u32 cp;
 
        err = 0;

-       err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
-       err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
-       err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
+       err |=
+           copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
+                          sizeof(arg64.LUN_info));
+       err |=
+           copy_from_user(&arg64.Request, &arg32->Request,
+                          sizeof(arg64.Request));
+       err |=
+           copy_from_user(&arg64.error_info, &arg32->error_info,
+                          sizeof(arg64.error_info));

        err |= get_user(arg64.buf_size, &arg32->buf_size);
        err |= get_user(arg64.malloc_size, &arg32->malloc_size);
        err |= get_user(cp, &arg32->buf);
        err |= get_user(arg64.buf_size, &arg32->buf_size);
        err |= get_user(arg64.malloc_size, &arg32->malloc_size);
        err |= get_user(cp, &arg32->buf);


@@ -624,12 +644,14 @@ static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned
        err |= copy_to_user(p, &arg64, sizeof(arg64));
 
        if (err)
        err |= copy_to_user(p, &arg64, sizeof(arg64));
 
        if (err)

-                return -EFAULT;
+               return -EFAULT;

 
 

-       err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long) p);
+       err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);

        if (err)
                return err;
        if (err)
                return err;

-       err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
+       err |=
+           copy_in_user(&arg32->error_info, &p->error_info,
+                        sizeof(arg32->error_info));

        if (err)
                return -EFAULT;
        return err;
        if (err)
                return -EFAULT;
        return err;


@@ -650,10 +672,10 @@ static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 }
 
 /*
 }
 
 /*

- * ioctl 
+ * ioctl

  */
  */

-static int cciss_ioctl(struct inode *inode, struct file *filep, 
-               unsigned int cmd, unsigned long arg)
+static int cciss_ioctl(struct inode *inode, struct file *filep,
+                      unsigned int cmd, unsigned long arg)

 {
        struct block_device *bdev = inode->i_bdev;
        struct gendisk *disk = bdev->bd_disk;
 {
        struct block_device *bdev = inode->i_bdev;
        struct gendisk *disk = bdev->bd_disk;


@@ -664,521 +686,476 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
 
 #ifdef CCISS_DEBUG
        printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
 
 #ifdef CCISS_DEBUG
        printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);

-#endif /* CCISS_DEBUG */ 
-       
-       switch(cmd) {
+#endif                         /* CCISS_DEBUG */
+
+       switch (cmd) {

        case CCISS_GETPCIINFO:
        case CCISS_GETPCIINFO:

-       {
-               cciss_pci_info_struct pciinfo;
-
-               if (!arg) return -EINVAL;
-               pciinfo.domain = pci_domain_nr(host->pdev->bus);
-               pciinfo.bus = host->pdev->bus->number;
-               pciinfo.dev_fn = host->pdev->devfn;
-               pciinfo.board_id = host->board_id;
-               if (copy_to_user(argp, &pciinfo,  sizeof( cciss_pci_info_struct )))
-                       return  -EFAULT;
-               return(0);
-       }       
+               {
+                       cciss_pci_info_struct pciinfo;
+
+                       if (!arg)
+                               return -EINVAL;
+                       pciinfo.domain = pci_domain_nr(host->pdev->bus);
+                       pciinfo.bus = host->pdev->bus->number;
+                       pciinfo.dev_fn = host->pdev->devfn;
+                       pciinfo.board_id = host->board_id;
+                       if (copy_to_user
+                           (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
+                               return -EFAULT;
+                       return 0;
+               }

        case CCISS_GETINTINFO:
        case CCISS_GETINTINFO:

-       {
-               cciss_coalint_struct intinfo;
-               if (!arg) return -EINVAL;
-               intinfo.delay = readl(&host->cfgtable->HostWrite.CoalIntDelay);
-               intinfo.count = readl(&host->cfgtable->HostWrite.CoalIntCount);
-               if (copy_to_user(argp, &intinfo, sizeof( cciss_coalint_struct )))
-                       return -EFAULT;
-                return(0);
-        }
+               {
+                       cciss_coalint_struct intinfo;
+                       if (!arg)
+                               return -EINVAL;
+                       intinfo.delay =
+                           readl(&host->cfgtable->HostWrite.CoalIntDelay);
+                       intinfo.count =
+                           readl(&host->cfgtable->HostWrite.CoalIntCount);
+                       if (copy_to_user
+                           (argp, &intinfo, sizeof(cciss_coalint_struct)))
+                               return -EFAULT;
+                       return 0;
+               }

        case CCISS_SETINTINFO:
        case CCISS_SETINTINFO:

-        {
-                cciss_coalint_struct intinfo;
-               unsigned long flags;
-               int i;
-
-               if (!arg) return -EINVAL;       
-               if (!capable(CAP_SYS_ADMIN)) return -EPERM;
-               if (copy_from_user(&intinfo, argp, sizeof( cciss_coalint_struct)))
-                       return -EFAULT;
-               if ( (intinfo.delay == 0 ) && (intinfo.count == 0))
-

                {
                {

-//                     printk("cciss_ioctl: delay and count cannot be 0\n");
-                       return( -EINVAL);
+                       cciss_coalint_struct intinfo;
+                       unsigned long flags;
+                       int i;
+
+                       if (!arg)
+                               return -EINVAL;
+                       if (!capable(CAP_SYS_ADMIN))
+                               return -EPERM;
+                       if (copy_from_user
+                           (&intinfo, argp, sizeof(cciss_coalint_struct)))
+                               return -EFAULT;
+                       if ((intinfo.delay == 0) && (intinfo.count == 0))
+                       {
+//                      printk("cciss_ioctl: delay and count cannot be 0\n");
+                               return -EINVAL;
+                       }
+                       spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+                       /* Update the field, and then ring the doorbell */
+                       writel(intinfo.delay,
+                              &(host->cfgtable->HostWrite.CoalIntDelay));
+                       writel(intinfo.count,
+                              &(host->cfgtable->HostWrite.CoalIntCount));
+                       writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
+
+                       for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
+                               if (!(readl(host->vaddr + SA5_DOORBELL)
+                                     & CFGTBL_ChangeReq))
+                                       break;
+                               /* delay and try again */
+                               udelay(1000);
+                       }
+                       spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+                       if (i >= MAX_IOCTL_CONFIG_WAIT)
+                               return -EAGAIN;
+                       return 0;

                }
                }

-               spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-               /* Update the field, and then ring the doorbell */ 
-               writel( intinfo.delay, 
-                       &(host->cfgtable->HostWrite.CoalIntDelay));
-               writel( intinfo.count, 
-                        &(host->cfgtable->HostWrite.CoalIntCount));
-               writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
-
-               for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
-                       if (!(readl(host->vaddr + SA5_DOORBELL) 
-                                       & CFGTBL_ChangeReq))
-                               break;
-                       /* delay and try again */
-                       udelay(1000);
-               }       
-               spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-               if (i >= MAX_IOCTL_CONFIG_WAIT)
-                       return -EAGAIN;
-                return(0);
-        }

        case CCISS_GETNODENAME:
        case CCISS_GETNODENAME:

-        {
-                NodeName_type NodeName;
-               int i; 
-
-               if (!arg) return -EINVAL;
-               for(i=0;i<16;i++)
-                       NodeName[i] = readb(&host->cfgtable->ServerName[i]);
-                if (copy_to_user(argp, NodeName, sizeof( NodeName_type)))
-                       return  -EFAULT;
-                return(0);
-        }
-       case CCISS_SETNODENAME:
-       {
-               NodeName_type NodeName;
-               unsigned long flags;
-               int i;
-
-               if (!arg) return -EINVAL;
-               if (!capable(CAP_SYS_ADMIN)) return -EPERM;
-               
-               if (copy_from_user(NodeName, argp, sizeof( NodeName_type)))
-                       return -EFAULT;
-
-               spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-
-                       /* Update the field, and then ring the doorbell */ 
-               for(i=0;i<16;i++)
-                       writeb( NodeName[i], &host->cfgtable->ServerName[i]);
-                       
-               writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
-
-               for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
-                       if (!(readl(host->vaddr + SA5_DOORBELL) 
-                                       & CFGTBL_ChangeReq))
-                               break;
-                       /* delay and try again */
-                       udelay(1000);
-               }       
-               spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-               if (i >= MAX_IOCTL_CONFIG_WAIT)
-                       return -EAGAIN;
-                return(0);
-        }
+               {
+                       NodeName_type NodeName;
+                       int i;

 
 

-       case CCISS_GETHEARTBEAT:
-        {
-                Heartbeat_type heartbeat;
-
-               if (!arg) return -EINVAL;
-                heartbeat = readl(&host->cfgtable->HeartBeat);
-                if (copy_to_user(argp, &heartbeat, sizeof( Heartbeat_type)))
-                       return -EFAULT;
-                return(0);
-        }
-       case CCISS_GETBUSTYPES:
-        {
-                BusTypes_type BusTypes;
-
-               if (!arg) return -EINVAL;
-                BusTypes = readl(&host->cfgtable->BusTypes);
-                if (copy_to_user(argp, &BusTypes, sizeof( BusTypes_type) ))
-                       return  -EFAULT;
-                return(0);
-        }
-       case CCISS_GETFIRMVER:
-        {
-               FirmwareVer_type firmware;
+                       if (!arg)
+                               return -EINVAL;
+                       for (i = 0; i < 16; i++)
+                               NodeName[i] =
+                                   readb(&host->cfgtable->ServerName[i]);
+                       if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
+                               return -EFAULT;
+                       return 0;
+               }
+       case CCISS_SETNODENAME:
+               {
+                       NodeName_type NodeName;
+                       unsigned long flags;
+                       int i;

 
 

-               if (!arg) return -EINVAL;
-               memcpy(firmware, host->firm_ver, 4);
+                       if (!arg)
+                               return -EINVAL;
+                       if (!capable(CAP_SYS_ADMIN))
+                               return -EPERM;

 
 

-                if (copy_to_user(argp, firmware, sizeof( FirmwareVer_type)))
-                       return -EFAULT;
-                return(0);
-        }
-        case CCISS_GETDRIVVER:
-        {
-               DriverVer_type DriverVer = DRIVER_VERSION;
+                       if (copy_from_user
+                           (NodeName, argp, sizeof(NodeName_type)))
+                               return -EFAULT;

 
 

-                if (!arg) return -EINVAL;
+                       spin_lock_irqsave(CCISS_LOCK(ctlr), flags);

 
 

-                if (copy_to_user(argp, &DriverVer, sizeof( DriverVer_type) ))
-                       return -EFAULT;
-                return(0);
-        }
+                       /* Update the field, and then ring the doorbell */
+                       for (i = 0; i < 16; i++)
+                               writeb(NodeName[i],
+                                      &host->cfgtable->ServerName[i]);

 
 

-       case CCISS_REVALIDVOLS:
-               if (bdev != bdev->bd_contains || drv != host->drv)
-                       return -ENXIO;
-                return revalidate_allvol(host);
-
-       case CCISS_GETLUNINFO: {
-               LogvolInfo_struct luninfo;
-               
-               luninfo.LunID = drv->LunID;
-               luninfo.num_opens = drv->usage_count;
-               luninfo.num_parts = 0;
-               if (copy_to_user(argp, &luninfo,
-                               sizeof(LogvolInfo_struct)))
-                       return -EFAULT;
-               return(0);
-       }
-       case CCISS_DEREGDISK:
-               return rebuild_lun_table(host, disk);
+                       writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);

 
 

-       case CCISS_REGNEWD:
-               return rebuild_lun_table(host, NULL);
+                       for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
+                               if (!(readl(host->vaddr + SA5_DOORBELL)
+                                     & CFGTBL_ChangeReq))
+                                       break;
+                               /* delay and try again */
+                               udelay(1000);
+                       }
+                       spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+                       if (i >= MAX_IOCTL_CONFIG_WAIT)
+                               return -EAGAIN;
+                       return 0;
+               }

 
 

-       case CCISS_PASSTHRU:
-       {
-               IOCTL_Command_struct iocommand;
-               CommandList_struct *c;
-               char    *buff = NULL;
-               u64bit  temp64;
-               unsigned long flags;
-               DECLARE_COMPLETION(wait);
-
-               if (!arg) return -EINVAL;
-       
-               if (!capable(CAP_SYS_RAWIO)) return -EPERM;
-
-               if (copy_from_user(&iocommand, argp, sizeof( IOCTL_Command_struct) ))
-                       return -EFAULT;
-               if((iocommand.buf_size < 1) && 
-                               (iocommand.Request.Type.Direction != XFER_NONE))
-               {       
-                       return -EINVAL;
-               } 
-#if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
-               /* Check kmalloc limits */
-               if(iocommand.buf_size > 128000)
-                       return -EINVAL;
-#endif
-               if(iocommand.buf_size > 0)
+       case CCISS_GETHEARTBEAT:

                {
                {

-                       buff =  kmalloc(iocommand.buf_size, GFP_KERNEL);
-                       if( buff == NULL) 
+                       Heartbeat_type heartbeat;
+
+                       if (!arg)
+                               return -EINVAL;
+                       heartbeat = readl(&host->cfgtable->HeartBeat);
+                       if (copy_to_user
+                           (argp, &heartbeat, sizeof(Heartbeat_type)))

                                return -EFAULT;
                                return -EFAULT;

+                       return 0;

                }
                }

-               if (iocommand.Request.Type.Direction == XFER_WRITE)
+       case CCISS_GETBUSTYPES:

                {
                {

-                       /* Copy the data into the buffer we created */ 
-                       if (copy_from_user(buff, iocommand.buf, iocommand.buf_size))
-                       {
-                               kfree(buff);
+                       BusTypes_type BusTypes;
+
+                       if (!arg)
+                               return -EINVAL;
+                       BusTypes = readl(&host->cfgtable->BusTypes);
+                       if (copy_to_user
+                           (argp, &BusTypes, sizeof(BusTypes_type)))

                                return -EFAULT;
                                return -EFAULT;

-                       }
-               } else {
-                       memset(buff, 0, iocommand.buf_size);
+                       return 0;

                }
                }

-               if ((c = cmd_alloc(host , 0)) == NULL)
-               {
-                       kfree(buff);
-                       return -ENOMEM;
-               }
-                       // Fill in the command type 
-               c->cmd_type = CMD_IOCTL_PEND;
-                       // Fill in Command Header 
-               c->Header.ReplyQueue = 0;  // unused in simple mode
-               if( iocommand.buf_size > 0)     // buffer to fill 
-               {
-                       c->Header.SGList = 1;
-                       c->Header.SGTotal= 1;
-               } else  // no buffers to fill  
+       case CCISS_GETFIRMVER:

                {
                {

-                       c->Header.SGList = 0;
-                       c->Header.SGTotal= 0;
+                       FirmwareVer_type firmware;
+
+                       if (!arg)
+                               return -EINVAL;
+                       memcpy(firmware, host->firm_ver, 4);
+
+                       if (copy_to_user
+                           (argp, firmware, sizeof(FirmwareVer_type)))
+                               return -EFAULT;
+                       return 0;

                }
                }

-               c->Header.LUN = iocommand.LUN_info;
-               c->Header.Tag.lower = c->busaddr;  // use the kernel address the cmd block for tag
-               
-               // Fill in Request block 
-               c->Request = iocommand.Request; 
-       
-               // Fill in the scatter gather information
-               if (iocommand.buf_size > 0 ) 
+       case CCISS_GETDRIVVER:

                {
                {

-                       temp64.val = pci_map_single( host->pdev, buff,
-                                        iocommand.buf_size, 
-                                PCI_DMA_BIDIRECTIONAL);        
-                       c->SG[0].Addr.lower = temp64.val32.lower;
-                       c->SG[0].Addr.upper = temp64.val32.upper;
-                       c->SG[0].Len = iocommand.buf_size;
-                       c->SG[0].Ext = 0;  // we are not chaining
+                       DriverVer_type DriverVer = DRIVER_VERSION;
+
+                       if (!arg)
+                               return -EINVAL;
+
+                       if (copy_to_user
+                           (argp, &DriverVer, sizeof(DriverVer_type)))
+                               return -EFAULT;
+                       return 0;

                }
                }

-               c->waiting = &wait;

 
 

-               /* Put the request on the tail of the request queue */
-               spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-               addQ(&host->reqQ, c);
-               host->Qdepth++;
-               start_io(host);
-               spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+       case CCISS_REVALIDVOLS:
+               return rebuild_lun_table(host, NULL);

 
 

-               wait_for_completion(&wait);
+       case CCISS_GETLUNINFO:{
+                       LogvolInfo_struct luninfo;
+
+                       luninfo.LunID = drv->LunID;
+                       luninfo.num_opens = drv->usage_count;
+                       luninfo.num_parts = 0;
+                       if (copy_to_user(argp, &luninfo,
+                                        sizeof(LogvolInfo_struct)))
+                               return -EFAULT;
+                       return 0;
+               }
+       case CCISS_DEREGDISK:
+               return rebuild_lun_table(host, disk);

 
 

-               /* unlock the buffers from DMA */
-               temp64.val32.lower = c->SG[0].Addr.lower;
-                temp64.val32.upper = c->SG[0].Addr.upper;
-                pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
-                       iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
+       case CCISS_REGNEWD:
+               return rebuild_lun_table(host, NULL);

 
 

-               /* Copy the error information out */ 
-               iocommand.error_info = *(c->err_info);
-               if ( copy_to_user(argp, &iocommand, sizeof( IOCTL_Command_struct) ) )
+       case CCISS_PASSTHRU:

                {
                {

-                       kfree(buff);
-                       cmd_free(host, c, 0);
-                       return( -EFAULT);       
-               }       
+                       IOCTL_Command_struct iocommand;
+                       CommandList_struct *c;
+                       char *buff = NULL;
+                       u64bit temp64;
+                       unsigned long flags;
+                       DECLARE_COMPLETION_ONSTACK(wait);
+
+                       if (!arg)
+                               return -EINVAL;

 
 

-               if (iocommand.Request.Type.Direction == XFER_READ)
-                {
-                        /* Copy the data out of the buffer we created */
-                        if (copy_to_user(iocommand.buf, buff, iocommand.buf_size))
+                       if (!capable(CAP_SYS_RAWIO))
+                               return -EPERM;
+
+                       if (copy_from_user
+                           (&iocommand, argp, sizeof(IOCTL_Command_struct)))
+                               return -EFAULT;
+                       if ((iocommand.buf_size < 1) &&
+                           (iocommand.Request.Type.Direction != XFER_NONE)) {
+                               return -EINVAL;
+                       }
+#if 0                          /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
+                       /* Check kmalloc limits */
+                       if (iocommand.buf_size > 128000)
+                               return -EINVAL;
+#endif
+                       if (iocommand.buf_size > 0) {
+                               buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
+                               if (buff == NULL)
+                                       return -EFAULT;
+                       }
+                       if (iocommand.Request.Type.Direction == XFER_WRITE) {
+                               /* Copy the data into the buffer we created */
+                               if (copy_from_user
+                                   (buff, iocommand.buf, iocommand.buf_size)) {
+                                       kfree(buff);
+                                       return -EFAULT;
+                               }
+                       } else {
+                               memset(buff, 0, iocommand.buf_size);
+                       }
+                       if ((c = cmd_alloc(host, 0)) == NULL) {
+                               kfree(buff);
+                               return -ENOMEM;
+                       }
+                       // Fill in the command type
+                       c->cmd_type = CMD_IOCTL_PEND;
+                       // Fill in Command Header
+                       c->Header.ReplyQueue = 0;       // unused in simple mode
+                       if (iocommand.buf_size > 0)     // buffer to fill
+                       {
+                               c->Header.SGList = 1;
+                               c->Header.SGTotal = 1;
+                       } else  // no buffers to fill

                        {
                        {

-                               kfree(buff);
+                               c->Header.SGList = 0;
+                               c->Header.SGTotal = 0;
+                       }
+                       c->Header.LUN = iocommand.LUN_info;
+                       c->Header.Tag.lower = c->busaddr;       // use the kernel address the cmd block for tag
+
+                       // Fill in Request block
+                       c->Request = iocommand.Request;
+
+                       // Fill in the scatter gather information
+                       if (iocommand.buf_size > 0) {
+                               temp64.val = pci_map_single(host->pdev, buff,
+                                       iocommand.buf_size,
+                                       PCI_DMA_BIDIRECTIONAL);
+                               c->SG[0].Addr.lower = temp64.val32.lower;
+                               c->SG[0].Addr.upper = temp64.val32.upper;
+                               c->SG[0].Len = iocommand.buf_size;
+                               c->SG[0].Ext = 0;       // we are not chaining
+                       }
+                       c->waiting = &wait;
+
+                       /* Put the request on the tail of the request queue */
+                       spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+                       addQ(&host->reqQ, c);
+                       host->Qdepth++;
+                       start_io(host);
+                       spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+
+                       wait_for_completion(&wait);
+
+                       /* unlock the buffers from DMA */
+                       temp64.val32.lower = c->SG[0].Addr.lower;
+                       temp64.val32.upper = c->SG[0].Addr.upper;
+                       pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
+                                        iocommand.buf_size,
+                                        PCI_DMA_BIDIRECTIONAL);
+
+                       /* Copy the error information out */
+                       iocommand.error_info = *(c->err_info);
+                       if (copy_to_user
+                           (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
+                               kfree(buff);

                                cmd_free(host, c, 0);
                                return -EFAULT;
                        }
                                cmd_free(host, c, 0);
                                return -EFAULT;
                        }

-                }
-                kfree(buff);
-               cmd_free(host, c, 0);
-                return(0);
-       } 
-       case CCISS_BIG_PASSTHRU: {
-               BIG_IOCTL_Command_struct *ioc;
-               CommandList_struct *c;
-               unsigned char **buff = NULL;
-               int     *buff_size = NULL;
-               u64bit  temp64;
-               unsigned long flags;
-               BYTE sg_used = 0;
-               int status = 0;
-               int i;
-               DECLARE_COMPLETION(wait);
-               __u32   left;
-               __u32   sz;
-               BYTE    __user *data_ptr;
-
-               if (!arg)
-                       return -EINVAL;
-               if (!capable(CAP_SYS_RAWIO))
-                       return -EPERM;
-               ioc = (BIG_IOCTL_Command_struct *) 
-                       kmalloc(sizeof(*ioc), GFP_KERNEL);
-               if (!ioc) {
-                       status = -ENOMEM;
-                       goto cleanup1;
-               }
-               if (copy_from_user(ioc, argp, sizeof(*ioc))) {
-                       status = -EFAULT;
-                       goto cleanup1;
+
+                       if (iocommand.Request.Type.Direction == XFER_READ) {
+                               /* Copy the data out of the buffer we created */
+                               if (copy_to_user
+                                   (iocommand.buf, buff, iocommand.buf_size)) {
+                                       kfree(buff);
+                                       cmd_free(host, c, 0);
+                                       return -EFAULT;
+                               }
+                       }
+                       kfree(buff);
+                       cmd_free(host, c, 0);
+                       return 0;

                }
                }

-               if ((ioc->buf_size < 1) &&
-                       (ioc->Request.Type.Direction != XFER_NONE)) {
+       case CCISS_BIG_PASSTHRU:{
+                       BIG_IOCTL_Command_struct *ioc;
+                       CommandList_struct *c;
+                       unsigned char **buff = NULL;
+                       int *buff_size = NULL;
+                       u64bit temp64;
+                       unsigned long flags;
+                       BYTE sg_used = 0;
+                       int status = 0;
+                       int i;
+                       DECLARE_COMPLETION_ONSTACK(wait);
+                       __u32 left;
+                       __u32 sz;
+                       BYTE __user *data_ptr;
+
+                       if (!arg)
+                               return -EINVAL;
+                       if (!capable(CAP_SYS_RAWIO))
+                               return -EPERM;
+                       ioc = (BIG_IOCTL_Command_struct *)
+                           kmalloc(sizeof(*ioc), GFP_KERNEL);
+                       if (!ioc) {
+                               status = -ENOMEM;
+                               goto cleanup1;
+                       }
+                       if (copy_from_user(ioc, argp, sizeof(*ioc))) {
+                               status = -EFAULT;
+                               goto cleanup1;
+                       }
+                       if ((ioc->buf_size < 1) &&
+                           (ioc->Request.Type.Direction != XFER_NONE)) {

                                status = -EINVAL;
                                goto cleanup1;
                                status = -EINVAL;
                                goto cleanup1;

-               }
-               /* Check kmalloc limits  using all SGs */
-               if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
-                       status = -EINVAL;
-                       goto cleanup1;
-               }
-               if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
-                       status = -EINVAL;
-                       goto cleanup1;
-               }
-               buff = (unsigned char **) kmalloc(MAXSGENTRIES * 
-                               sizeof(char *), GFP_KERNEL);
-               if (!buff) {
-                       status = -ENOMEM;
-                       goto cleanup1;
-               }
-               memset(buff, 0, MAXSGENTRIES);
-               buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int), 
-                                       GFP_KERNEL);
-               if (!buff_size) {
-                       status = -ENOMEM;
-                       goto cleanup1;
-               }
-               left = ioc->buf_size;
-               data_ptr = ioc->buf;
-               while (left) {
-                       sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
-                       buff_size[sg_used] = sz;
-                       buff[sg_used] = kmalloc(sz, GFP_KERNEL);
-                       if (buff[sg_used] == NULL) {
+                       }
+                       /* Check kmalloc limits  using all SGs */
+                       if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
+                               status = -EINVAL;
+                               goto cleanup1;
+                       }
+                       if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
+                               status = -EINVAL;
+                               goto cleanup1;
+                       }
+                       buff =
+                           kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
+                       if (!buff) {

                                status = -ENOMEM;
                                goto cleanup1;
                        }
                                status = -ENOMEM;
                                goto cleanup1;
                        }

-                       if (ioc->Request.Type.Direction == XFER_WRITE) {
-                               if (copy_from_user(buff[sg_used], data_ptr, sz)) {
+                       buff_size = kmalloc(MAXSGENTRIES * sizeof(int),
+                                                  GFP_KERNEL);
+                       if (!buff_size) {
+                               status = -ENOMEM;
+                               goto cleanup1;
+                       }
+                       left = ioc->buf_size;
+                       data_ptr = ioc->buf;
+                       while (left) {
+                               sz = (left >
+                                     ioc->malloc_size) ? ioc->
+                                   malloc_size : left;
+                               buff_size[sg_used] = sz;
+                               buff[sg_used] = kmalloc(sz, GFP_KERNEL);
+                               if (buff[sg_used] == NULL) {

                                        status = -ENOMEM;
                                        goto cleanup1;
                                }
                                        status = -ENOMEM;
                                        goto cleanup1;
                                }

+                               if (ioc->Request.Type.Direction == XFER_WRITE) {
+                                       if (copy_from_user
+                                           (buff[sg_used], data_ptr, sz)) {
+                                               status = -ENOMEM;
+                                               goto cleanup1;
+                                       }
+                               } else {
+                                       memset(buff[sg_used], 0, sz);
+                               }
+                               left -= sz;
+                               data_ptr += sz;
+                               sg_used++;
+                       }
+                       if ((c = cmd_alloc(host, 0)) == NULL) {
+                               status = -ENOMEM;
+                               goto cleanup1;
+                       }
+                       c->cmd_type = CMD_IOCTL_PEND;
+                       c->Header.ReplyQueue = 0;
+
+                       if (ioc->buf_size > 0) {
+                               c->Header.SGList = sg_used;
+                               c->Header.SGTotal = sg_used;

                        } else {
                        } else {

-                               memset(buff[sg_used], 0, sz);
+                               c->Header.SGList = 0;
+                               c->Header.SGTotal = 0;

                        }
                        }

-                       left -= sz;
-                       data_ptr += sz;
-                       sg_used++;
-               }
-               if ((c = cmd_alloc(host , 0)) == NULL) {
-                       status = -ENOMEM;
-                       goto cleanup1;  
-               }
-               c->cmd_type = CMD_IOCTL_PEND;
-               c->Header.ReplyQueue = 0;
-               
-               if( ioc->buf_size > 0) {
-                       c->Header.SGList = sg_used;
-                       c->Header.SGTotal= sg_used;
-               } else { 
-                       c->Header.SGList = 0;
-                       c->Header.SGTotal= 0;
-               }
-               c->Header.LUN = ioc->LUN_info;
-               c->Header.Tag.lower = c->busaddr;
-               
-               c->Request = ioc->Request;
-               if (ioc->buf_size > 0 ) {
-                       int i;
-                       for(i=0; i<sg_used; i++) {
-                               temp64.val = pci_map_single( host->pdev, buff[i],
-                                       buff_size[i],
+                       c->Header.LUN = ioc->LUN_info;
+                       c->Header.Tag.lower = c->busaddr;
+
+                       c->Request = ioc->Request;
+                       if (ioc->buf_size > 0) {
+                               int i;
+                               for (i = 0; i < sg_used; i++) {
+                                       temp64.val =
+                                           pci_map_single(host->pdev, buff[i],
+                                                   buff_size[i],
+                                                   PCI_DMA_BIDIRECTIONAL);
+                                       c->SG[i].Addr.lower =
+                                           temp64.val32.lower;
+                                       c->SG[i].Addr.upper =
+                                           temp64.val32.upper;
+                                       c->SG[i].Len = buff_size[i];
+                                       c->SG[i].Ext = 0;       /* we are not chaining */
+                               }
+                       }
+                       c->waiting = &wait;
+                       /* Put the request on the tail of the request queue */
+                       spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+                       addQ(&host->reqQ, c);
+                       host->Qdepth++;
+                       start_io(host);
+                       spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+                       wait_for_completion(&wait);
+                       /* unlock the buffers from DMA */
+                       for (i = 0; i < sg_used; i++) {
+                               temp64.val32.lower = c->SG[i].Addr.lower;
+                               temp64.val32.upper = c->SG[i].Addr.upper;
+                               pci_unmap_single(host->pdev,
+                                       (dma_addr_t) temp64.val, buff_size[i],

                                        PCI_DMA_BIDIRECTIONAL);
                                        PCI_DMA_BIDIRECTIONAL);

-                               c->SG[i].Addr.lower = temp64.val32.lower;
-                               c->SG[i].Addr.upper = temp64.val32.upper;
-                               c->SG[i].Len = buff_size[i];
-                               c->SG[i].Ext = 0;  /* we are not chaining */

                        }
                        }

-               }
-               c->waiting = &wait;
-               /* Put the request on the tail of the request queue */
-               spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-               addQ(&host->reqQ, c);
-               host->Qdepth++;
-               start_io(host);
-               spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-               wait_for_completion(&wait);
-               /* unlock the buffers from DMA */
-               for(i=0; i<sg_used; i++) {
-                       temp64.val32.lower = c->SG[i].Addr.lower;
-                       temp64.val32.upper = c->SG[i].Addr.upper;
-                       pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
-                               buff_size[i], PCI_DMA_BIDIRECTIONAL);
-               }
-               /* Copy the error information out */
-               ioc->error_info = *(c->err_info);
-               if (copy_to_user(argp, ioc, sizeof(*ioc))) {
-                       cmd_free(host, c, 0);
-                       status = -EFAULT;
-                       goto cleanup1;
-               }
-               if (ioc->Request.Type.Direction == XFER_READ) {
-                       /* Copy the data out of the buffer we created */
-                       BYTE __user *ptr = ioc->buf;
-                       for(i=0; i< sg_used; i++) {
-                               if (copy_to_user(ptr, buff[i], buff_size[i])) {
-                                       cmd_free(host, c, 0);
-                                       status = -EFAULT;
-                                       goto cleanup1;
+                       /* Copy the error information out */
+                       ioc->error_info = *(c->err_info);
+                       if (copy_to_user(argp, ioc, sizeof(*ioc))) {
+                               cmd_free(host, c, 0);
+                               status = -EFAULT;
+                               goto cleanup1;
+                       }
+                       if (ioc->Request.Type.Direction == XFER_READ) {
+                               /* Copy the data out of the buffer we created */
+                               BYTE __user *ptr = ioc->buf;
+                               for (i = 0; i < sg_used; i++) {
+                                       if (copy_to_user
+                                           (ptr, buff[i], buff_size[i])) {
+                                               cmd_free(host, c, 0);
+                                               status = -EFAULT;
+                                               goto cleanup1;
+                                       }
+                                       ptr += buff_size[i];

                                }
                                }

-                               ptr += buff_size[i];

                        }
                        }

+                       cmd_free(host, c, 0);
+                       status = 0;
+                     cleanup1:
+                       if (buff) {
+                               for (i = 0; i < sg_used; i++)
+                                       kfree(buff[i]);
+                               kfree(buff);
+                       }
+                       kfree(buff_size);
+                       kfree(ioc);
+                       return status;

                }
                }

-               cmd_free(host, c, 0);
-               status = 0;
-cleanup1:
-               if (buff) {
-                       for(i=0; i<sg_used; i++)
-                               kfree(buff[i]);
-                       kfree(buff);
-               }
-               kfree(buff_size);
-               kfree(ioc);
-               return(status);
-       }

        default:
                return -ENOTTY;
        }
        default:
                return -ENOTTY;
        }

-       
-}
-
-/*
- * revalidate_allvol is for online array config utilities.  After a
- * utility reconfigures the drives in the array, it can use this function
- * (through an ioctl) to make the driver zap any previous disk structs for
- * that controller and get new ones.
- *
- * Right now I'm using the getgeometry() function to do this, but this
- * function should probably be finer grained and allow you to revalidate one
- * particualar logical volume (instead of all of them on a particular
- * controller).
- */
-static int revalidate_allvol(ctlr_info_t *host)
-{
-       int ctlr = host->ctlr, i;
-       unsigned long flags;
-
-        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-        if (host->usage_count > 1) {
-                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-                printk(KERN_WARNING "cciss: Device busy for volume"
-                        " revalidation (usage=%d)\n", host->usage_count);
-                return -EBUSY;
-        }
-        host->usage_count++;
-       spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-
-       for(i=0; i< NWD; i++) {
-               struct gendisk *disk = host->gendisk[i];
-               if (disk) {
-                       request_queue_t *q = disk->queue;
-
-                       if (disk->flags & GENHD_FL_UP)
-                               del_gendisk(disk);
-                       if (q)
-                               blk_cleanup_queue(q);
-               }
-       }
-
-        /*
-         * Set the partition and block size structures for all volumes
-         * on this controller to zero.  We will reread all of this data
-         */
-        memset(host->drv,        0, sizeof(drive_info_struct)
-                                               * CISS_MAX_LUN);
-        /*
-         * Tell the array controller not to give us any interrupts while
-         * we check the new geometry.  Then turn interrupts back on when
-         * we're done.
-         */
-        host->access.set_intr_mask(host, CCISS_INTR_OFF);
-        cciss_getgeometry(ctlr);
-        host->access.set_intr_mask(host, CCISS_INTR_ON);
-
-       /* Loop through each real device */ 
-       for (i = 0; i < NWD; i++) {
-               struct gendisk *disk = host->gendisk[i];
-               drive_info_struct *drv = &(host->drv[i]);
-               /* we must register the controller even if no disks exist */
-               /* this is for the online array utilities */
-               if (!drv->heads && i)
-                       continue;
-               blk_queue_hardsect_size(drv->queue, drv->block_size);
-               set_capacity(disk, drv->nr_blocks);
-               add_disk(disk);
-       }
-        host->usage_count--;
-        return 0;

 }
 
 static inline void complete_buffers(struct bio *bio, int status)
 }
 
 static inline void complete_buffers(struct bio *bio, int status)


@@ -1188,11 +1165,53 @@ static inline void complete_buffers(struct bio *bio, int status)
                int nr_sectors = bio_sectors(bio);
 
                bio->bi_next = NULL;
                int nr_sectors = bio_sectors(bio);
 
                bio->bi_next = NULL;

-               blk_finished_io(len);

                bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
                bio = xbh;
        }
                bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
                bio = xbh;
        }

+}

 
 

+static void cciss_check_queues(ctlr_info_t *h)
+{
+       int start_queue = h->next_to_run;
+       int i;
+
+       /* check to see if we have maxed out the number of commands that can
+        * be placed on the queue.  If so then exit.  We do this check here
+        * in case the interrupt we serviced was from an ioctl and did not
+        * free any new commands.
+        */
+       if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)
+               return;
+
+       /* We have room on the queue for more commands.  Now we need to queue
+        * them up.  We will also keep track of the next queue to run so
+        * that every queue gets a chance to be started first.
+        */
+       for (i = 0; i < h->highest_lun + 1; i++) {
+               int curr_queue = (start_queue + i) % (h->highest_lun + 1);
+               /* make sure the disk has been added and the drive is real
+                * because this can be called from the middle of init_one.
+                */
+               if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
+                       continue;
+               blk_start_queue(h->gendisk[curr_queue]->queue);
+
+               /* check to see if we have maxed out the number of commands
+                * that can be placed on the queue.
+                */
+               if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {
+                       if (curr_queue == start_queue) {
+                               h->next_to_run =
+                                   (start_queue + 1) % (h->highest_lun + 1);
+                               break;
+                       } else {
+                               h->next_to_run = curr_queue;
+                               break;
+                       }
+               } else {
+                       curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
+               }
+       }

 }
 
 static void cciss_softirq_done(struct request *rq)
 }
 
 static void cciss_softirq_done(struct request *rq)


@@ -1210,7 +1229,7 @@ static void cciss_softirq_done(struct request *rq)
 
        /* command did not need to be retried */
        /* unmap the DMA mapping for all the scatter gather elements */
 
        /* command did not need to be retried */
        /* unmap the DMA mapping for all the scatter gather elements */

-       for(i=0; i<cmd->Header.SGList; i++) {
+       for (i = 0; i < cmd->Header.SGList; i++) {

                temp64.val32.lower = cmd->SG[i].Addr.lower;
                temp64.val32.upper = cmd->SG[i].Addr.upper;
                pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
                temp64.val32.lower = cmd->SG[i].Addr.lower;
                temp64.val32.upper = cmd->SG[i].Addr.upper;
                pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);


@@ -1226,11 +1245,13 @@ static void cciss_softirq_done(struct request *rq)
 
 #ifdef CCISS_DEBUG
        printk("Done with %p\n", rq);
 
 #ifdef CCISS_DEBUG
        printk("Done with %p\n", rq);

-#endif /* CCISS_DEBUG */
+#endif                         /* CCISS_DEBUG */

 
 

+       add_disk_randomness(rq->rq_disk);

        spin_lock_irqsave(&h->lock, flags);
        end_that_request_last(rq, rq->errors);
        spin_lock_irqsave(&h->lock, flags);
        end_that_request_last(rq, rq->errors);

-       cmd_free(h, cmd,1);
+       cmd_free(h, cmd, 1);
+       cciss_check_queues(h);

        spin_unlock_irqrestore(&h->lock, flags);
 }
 
        spin_unlock_irqrestore(&h->lock, flags);
 }
 


@@ -1241,25 +1262,24 @@ static void cciss_softirq_done(struct request *rq)
  * will always be left registered with the kernel since it is also the
  * controller node.  Any changes to disk 0 will show up on the next
  * reboot.
  * will always be left registered with the kernel since it is also the
  * controller node.  Any changes to disk 0 will show up on the next
  * reboot.

-*/
+ */

 static void cciss_update_drive_info(int ctlr, int drv_index)
 static void cciss_update_drive_info(int ctlr, int drv_index)

-  {
+{

        ctlr_info_t *h = hba[ctlr];
        struct gendisk *disk;
        ctlr_info_t *h = hba[ctlr];
        struct gendisk *disk;

-       ReadCapdata_struct *size_buff = NULL;

        InquiryData_struct *inq_buff = NULL;
        unsigned int block_size;
        InquiryData_struct *inq_buff = NULL;
        unsigned int block_size;

-       unsigned int total_size;
+       sector_t total_size;

        unsigned long flags = 0;
        int ret = 0;
 
        unsigned long flags = 0;
        int ret = 0;
 

-       /* if the disk already exists then deregister it before proceeding*/
-       if (h->drv[drv_index].raid_level != -1){
+       /* if the disk already exists then deregister it before proceeding */
+       if (h->drv[drv_index].raid_level != -1) {

                spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
                h->drv[drv_index].busy_configuring = 1;
                spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                ret = deregister_disk(h->gendisk[drv_index],
                spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
                h->drv[drv_index].busy_configuring = 1;
                spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                ret = deregister_disk(h->gendisk[drv_index],

-                       &h->drv[drv_index], 0);
+                                     &h->drv[drv_index], 0);

                h->drv[drv_index].busy_configuring = 0;
        }
 
                h->drv[drv_index].busy_configuring = 0;
        }
 


@@ -1267,28 +1287,41 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
        if (ret)
                return;
 
        if (ret)
                return;
 

-
-       /* Get information about the disk and modify the driver sturcture */
-       size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
-        if (size_buff == NULL)
-               goto mem_msg;
-       inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
+       /* Get information about the disk and modify the driver structure */
+       inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);

        if (inq_buff == NULL)
                goto mem_msg;
 
        if (inq_buff == NULL)
                goto mem_msg;
 

-       cciss_read_capacity(ctlr, drv_index, size_buff, 1,
+       cciss_read_capacity(ctlr, drv_index, 1,
+                           &total_size, &block_size);
+
+       /* total size = last LBA + 1 */
+       /* FFFFFFFF + 1 = 0, cannot have a logical volume of size 0 */
+       /* so we assume this volume this must be >2TB in size */
+       if (total_size == (__u32) 0) {
+               cciss_read_capacity_16(ctlr, drv_index, 1,

                &total_size, &block_size);
                &total_size, &block_size);

+               h->cciss_read = CCISS_READ_16;
+               h->cciss_write = CCISS_WRITE_16;
+       } else {
+               h->cciss_read = CCISS_READ_10;
+               h->cciss_write = CCISS_WRITE_10;
+       }

        cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
        cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,

-               inq_buff, &h->drv[drv_index]);
+                              inq_buff, &h->drv[drv_index]);

 
        ++h->num_luns;
        disk = h->gendisk[drv_index];
        set_capacity(disk, h->drv[drv_index].nr_blocks);
 
 
        ++h->num_luns;
        disk = h->gendisk[drv_index];
        set_capacity(disk, h->drv[drv_index].nr_blocks);
 

-

        /* if it's the controller it's already added */
        /* if it's the controller it's already added */

-       if (drv_index){
+       if (drv_index) {

                disk->queue = blk_init_queue(do_cciss_request, &h->lock);
                disk->queue = blk_init_queue(do_cciss_request, &h->lock);

+               sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
+               disk->major = h->major;
+               disk->first_minor = drv_index << NWD_SHIFT;
+               disk->fops = &cciss_fops;
+               disk->private_data = &h->drv[drv_index];

 
                /* Set up queue information */
                disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
 
                /* Set up queue information */
                disk->queue->backing_dev_info.ra_pages = READ_AHEAD;


@@ -1300,24 +1333,23 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
                /* This is a limit in the driver and could be eliminated. */
                blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
 
                /* This is a limit in the driver and could be eliminated. */
                blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
 

-               blk_queue_max_sectors(disk->queue, 512);
+               blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);

 
                blk_queue_softirq_done(disk->queue, cciss_softirq_done);
 
                disk->queue->queuedata = hba[ctlr];
 
                blk_queue_hardsect_size(disk->queue,
 
                blk_queue_softirq_done(disk->queue, cciss_softirq_done);
 
                disk->queue->queuedata = hba[ctlr];
 
                blk_queue_hardsect_size(disk->queue,

-                       hba[ctlr]->drv[drv_index].block_size);
+                                       hba[ctlr]->drv[drv_index].block_size);

 
                h->drv[drv_index].queue = disk->queue;
                add_disk(disk);
        }
 
 
                h->drv[drv_index].queue = disk->queue;
                add_disk(disk);
        }
 

-freeret:
-       kfree(size_buff);
+      freeret:

        kfree(inq_buff);
        return;
        kfree(inq_buff);
        return;

-mem_msg:
+      mem_msg:

        printk(KERN_ERR "cciss: out of memory\n");
        goto freeret;
 }
        printk(KERN_ERR "cciss: out of memory\n");
        goto freeret;
 }


@@ -1327,13 +1359,13 @@ mem_msg:
  * where new drives will be added.  If the index to be returned is greater
  * than the highest_lun index for the controller then highest_lun is set
  * to this new index.  If there are no available indexes then -1 is returned.
  * where new drives will be added.  If the index to be returned is greater
  * than the highest_lun index for the controller then highest_lun is set
  * to this new index.  If there are no available indexes then -1 is returned.

-*/
+ */

 static int cciss_find_free_drive_index(int ctlr)
 {
        int i;
 
 static int cciss_find_free_drive_index(int ctlr)
 {
        int i;
 

-       for (i=0; i < CISS_MAX_LUN; i++){
-               if (hba[ctlr]->drv[i].raid_level == -1){
+       for (i = 0; i < CISS_MAX_LUN; i++) {
+               if (hba[ctlr]->drv[i].raid_level == -1) {

                        if (i > hba[ctlr]->highest_lun)
                                hba[ctlr]->highest_lun = i;
                        return i;
                        if (i > hba[ctlr]->highest_lun)
                                hba[ctlr]->highest_lun = i;
                        return i;


@@ -1343,7 +1375,7 @@ static int cciss_find_free_drive_index(int ctlr)
 }
 
 /* This function will add and remove logical drives from the Logical
 }
 
 /* This function will add and remove logical drives from the Logical

- * drive array of the controller and maintain persistancy of ordering
+ * drive array of the controller and maintain persistency of ordering

  * so that mount points are preserved until the next reboot.  This allows
  * for the removal of logical drives in the middle of the drive array
  * without a re-ordering of those drives.
  * so that mount points are preserved until the next reboot.  This allows
  * for the removal of logical drives in the middle of the drive array
  * without a re-ordering of those drives.


@@ -1351,7 +1383,7 @@ static int cciss_find_free_drive_index(int ctlr)
  * h           = The controller to perform the operations on
  * del_disk    = The disk to remove if specified.  If the value given
  *               is NULL then no disk is removed.
  * h           = The controller to perform the operations on
  * del_disk    = The disk to remove if specified.  If the value given
  *               is NULL then no disk is removed.

-*/
+ */

 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
 {
        int ctlr = h->ctlr;
 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
 {
        int ctlr = h->ctlr;


@@ -1368,12 +1400,7 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
 
        /* Set busy_configuring flag for this operation */
        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
 
        /* Set busy_configuring flag for this operation */
        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);

-       if (h->num_luns >= CISS_MAX_LUN){
-               spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
-               return -EINVAL;
-       }
-
-       if (h->busy_configuring){
+       if (h->busy_configuring) {

                spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                return -EBUSY;
        }
                spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                return -EBUSY;
        }


@@ -1383,7 +1410,7 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
         * and update the logical drive table.  If it is not NULL then
         * we will check if the disk is in use or not.
         */
         * and update the logical drive table.  If it is not NULL then
         * we will check if the disk is in use or not.
         */

-       if (del_disk != NULL){
+       if (del_disk != NULL) {

                drv = get_drv(del_disk);
                drv->busy_configuring = 1;
                spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                drv = get_drv(del_disk);
                drv->busy_configuring = 1;
                spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);


@@ -1401,80 +1428,85 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
                        goto mem_msg;
 
                return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
                        goto mem_msg;
 
                return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,

-                               sizeof(ReportLunData_struct), 0, 0, 0,
-                               TYPE_CMD);
-
-               if (return_code == IO_OK){
-                       listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
-                       listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
-                       listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
-                       listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
-               } else{ /* reading number of logical volumes failed */
+                                             sizeof(ReportLunData_struct), 0,
+                                             0, 0, TYPE_CMD);
+
+               if (return_code == IO_OK) {
+                       listlength =
+                               be32_to_cpu(*(__u32 *) ld_buff->LUNListLength);
+               } else {        /* reading number of logical volumes failed */

                        printk(KERN_WARNING "cciss: report logical volume"
                        printk(KERN_WARNING "cciss: report logical volume"

-                               " command failed\n");
+                              " command failed\n");

                        listlength = 0;
                        goto freeret;
                }
 
                num_luns = listlength / 8;      /* 8 bytes per entry */
                        listlength = 0;
                        goto freeret;
                }
 
                num_luns = listlength / 8;      /* 8 bytes per entry */

-               if (num_luns > CISS_MAX_LUN){
+               if (num_luns > CISS_MAX_LUN) {

                        num_luns = CISS_MAX_LUN;
                        printk(KERN_WARNING "cciss: more luns configured"
                        num_luns = CISS_MAX_LUN;
                        printk(KERN_WARNING "cciss: more luns configured"

-                               " on controller than can be handled by"
-                               " this driver.\n");
+                              " on controller than can be handled by"
+                              " this driver.\n");

                }
 
                /* Compare controller drive array to drivers drive array.
                }
 
                /* Compare controller drive array to drivers drive array.

-               * Check for updates in the drive information and any new drives
-               * on the controller.
-               */
-               for (i=0; i < num_luns; i++){
+                * Check for updates in the drive information and any new drives
+                * on the controller.
+                */
+               for (i = 0; i < num_luns; i++) {

                        int j;
 
                        drv_found = 0;
 
                        int j;
 
                        drv_found = 0;
 

-                       lunid = (0xff &
-                               (unsigned int)(ld_buff->LUN[i][3])) << 24;
-                       lunid |= (0xff &
-                               (unsigned int)(ld_buff->LUN[i][2])) << 16;
-                       lunid |= (0xff &
-                               (unsigned int)(ld_buff->LUN[i][1])) << 8;
-                       lunid |= 0xff &
-                               (unsigned int)(ld_buff->LUN[i][0]);
+                       lunid = (0xff &
+                                (unsigned int)(ld_buff->LUN[i][3])) << 24;
+                       lunid |= (0xff &
+                                 (unsigned int)(ld_buff->LUN[i][2])) << 16;
+                       lunid |= (0xff &
+                                 (unsigned int)(ld_buff->LUN[i][1])) << 8;
+                       lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);

 
                        /* Find if the LUN is already in the drive array
                         * of the controller.  If so then update its info
                         * if not is use.  If it does not exist then find
                         * the first free index and add it.
 
                        /* Find if the LUN is already in the drive array
                         * of the controller.  If so then update its info
                         * if not is use.  If it does not exist then find
                         * the first free index and add it.

-                       */
-                       for (j=0; j <= h->highest_lun; j++){
-                               if (h->drv[j].LunID == lunid){
+                        */
+                       for (j = 0; j <= h->highest_lun; j++) {
+                               if (h->drv[j].LunID == lunid) {

                                        drv_index = j;
                                        drv_found = 1;
                                }
                        }
 
                        /* check if the drive was found already in the array */
                                        drv_index = j;
                                        drv_found = 1;
                                }
                        }
 
                        /* check if the drive was found already in the array */

-                       if (!drv_found){
+                       if (!drv_found) {

                                drv_index = cciss_find_free_drive_index(ctlr);
                                if (drv_index == -1)
                                        goto freeret;
 
                                drv_index = cciss_find_free_drive_index(ctlr);
                                if (drv_index == -1)
                                        goto freeret;
 

+                               /*Check if the gendisk needs to be allocated */
+                               if (!h->gendisk[drv_index]){
+                                       h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT);
+                                       if (!h->gendisk[drv_index]){
+                                               printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index);
+                                               goto mem_msg;
+                                       }
+                               }

                        }
                        h->drv[drv_index].LunID = lunid;
                        cciss_update_drive_info(ctlr, drv_index);
                        }
                        h->drv[drv_index].LunID = lunid;
                        cciss_update_drive_info(ctlr, drv_index);

-               } /* end for */
-       } /* end else */
+               }               /* end for */
+       }                       /* end else */

 
 

-freeret:
+      freeret:

        kfree(ld_buff);
        h->busy_configuring = 0;
        /* We return -1 here to tell the ACU that we have registered/updated
         * all of the drives that we can and to keep it from calling us
         * additional times.
        kfree(ld_buff);
        h->busy_configuring = 0;
        /* We return -1 here to tell the ACU that we have registered/updated
         * all of the drives that we can and to keep it from calling us
         * additional times.

-       */
+        */

        return -1;
        return -1;

-mem_msg:
+      mem_msg:

        printk(KERN_ERR "cciss: out of memory\n");
        goto freeret;
 }
        printk(KERN_ERR "cciss: out of memory\n");
        goto freeret;
 }


@@ -1490,41 +1522,66 @@ mem_msg:
  * clear_all = This flag determines whether or not the disk information
  *             is going to be completely cleared out and the highest_lun
  *             reset.  Sometimes we want to clear out information about
  * clear_all = This flag determines whether or not the disk information
  *             is going to be completely cleared out and the highest_lun
  *             reset.  Sometimes we want to clear out information about

- *             the disk in preperation for re-adding it.  In this case
+ *             the disk in preparation for re-adding it.  In this case

  *             the highest_lun should be left unchanged and the LunID
  *             should not be cleared.
 */
 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
                           int clear_all)
 {
  *             the highest_lun should be left unchanged and the LunID
  *             should not be cleared.
 */
 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
                           int clear_all)
 {

+       int i;

        ctlr_info_t *h = get_host(disk);
 
        if (!capable(CAP_SYS_RAWIO))
                return -EPERM;
 
        /* make sure logical volume is NOT is use */
        ctlr_info_t *h = get_host(disk);
 
        if (!capable(CAP_SYS_RAWIO))
                return -EPERM;
 
        /* make sure logical volume is NOT is use */

-       if(clear_all || (h->gendisk[0] == disk)) {
-       if (drv->usage_count > 1)
-                return -EBUSY;
-       }
-        else
-               if( drv->usage_count > 0 )
-                       return -EBUSY;
+       if (clear_all || (h->gendisk[0] == disk)) {
+               if (drv->usage_count > 1)
+                       return -EBUSY;
+       } else if (drv->usage_count > 0)
+               return -EBUSY;

 
        /* invalidate the devices and deregister the disk.  If it is disk
         * zero do not deregister it but just zero out it's values.  This
         * allows us to delete disk zero but keep the controller registered.
 
        /* invalidate the devices and deregister the disk.  If it is disk
         * zero do not deregister it but just zero out it's values.  This
         * allows us to delete disk zero but keep the controller registered.

-       */
-       if (h->gendisk[0] != disk){
+        */
+       if (h->gendisk[0] != disk) {

                if (disk) {
                        request_queue_t *q = disk->queue;
                        if (disk->flags & GENHD_FL_UP)
                                del_gendisk(disk);
                        if (q) {
                                blk_cleanup_queue(q);
                if (disk) {
                        request_queue_t *q = disk->queue;
                        if (disk->flags & GENHD_FL_UP)
                                del_gendisk(disk);
                        if (q) {
                                blk_cleanup_queue(q);

+                               /* Set drv->queue to NULL so that we do not try
+                                * to call blk_start_queue on this queue in the
+                                * interrupt handler
+                                */

                                drv->queue = NULL;
                        }
                                drv->queue = NULL;
                        }

+                       /* If clear_all is set then we are deleting the logical
+                        * drive, not just refreshing its info.  For drives
+                        * other than disk 0 we will call put_disk.  We do not
+                        * do this for disk 0 as we need it to be able to
+                        * configure the controller.
+                       */
+                       if (clear_all){
+                               /* This isn't pretty, but we need to find the
+                                * disk in our array and NULL our the pointer.
+                                * This is so that we will call alloc_disk if
+                                * this index is used again later.
+                               */
+                               for (i=0; i < CISS_MAX_LUN; i++){
+                                       if(h->gendisk[i] == disk){
+                                               h->gendisk[i] = NULL;
+                                               break;
+                                       }
+                               }
+                               put_disk(disk);
+                       }

                }
                }

+       } else {
+               set_capacity(disk, 0);

        }
 
        --h->num_luns;
        }
 
        --h->num_luns;


@@ -1537,91 +1594,90 @@ static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
        drv->raid_level = -1;   /* This can be used as a flag variable to
                                 * indicate that this element of the drive
                                 * array is free.
        drv->raid_level = -1;   /* This can be used as a flag variable to
                                 * indicate that this element of the drive
                                 * array is free.

-                               */
-
-       if (clear_all){
-       /* check to see if it was the last disk */
-       if (drv == h->drv + h->highest_lun) {
-               /* if so, find the new hightest lun */
-               int i, newhighest =-1;
-               for(i=0; i<h->highest_lun; i++) {
-                       /* if the disk has size > 0, it is available */
+                                */
+
+       if (clear_all) {
+               /* check to see if it was the last disk */
+               if (drv == h->drv + h->highest_lun) {
+                       /* if so, find the new hightest lun */
+                       int i, newhighest = -1;
+                       for (i = 0; i < h->highest_lun; i++) {
+                               /* if the disk has size > 0, it is available */

                                if (h->drv[i].heads)
                                if (h->drv[i].heads)

-                               newhighest = i;
+                                       newhighest = i;
+                       }
+                       h->highest_lun = newhighest;

                }
                }

-               h->highest_lun = newhighest;
-       }

 
 

-       drv->LunID = 0;
+               drv->LunID = 0;

        }
        }

-       return(0);
+       return 0;

 }
 
 }
 

-static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
-       size_t size,
-       unsigned int use_unit_num, /* 0: address the controller,
-                                     1: address logical volume log_unit,
-                                     2: periph device address is scsi3addr */
-       unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr,
-       int cmd_type)
+static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,     /* 0: address the controller,
+                                                                                                                          1: address logical volume log_unit,
+                                                                                                                          2: periph device address is scsi3addr */
+                   unsigned int log_unit, __u8 page_code,
+                   unsigned char *scsi3addr, int cmd_type)

 {
 {

-       ctlr_info_t *h= hba[ctlr];
+       ctlr_info_t *h = hba[ctlr];

        u64bit buff_dma_handle;
        int status = IO_OK;
 
        c->cmd_type = CMD_IOCTL_PEND;
        c->Header.ReplyQueue = 0;
        u64bit buff_dma_handle;
        int status = IO_OK;
 
        c->cmd_type = CMD_IOCTL_PEND;
        c->Header.ReplyQueue = 0;

-       if( buff != NULL) {
+       if (buff != NULL) {

                c->Header.SGList = 1;
                c->Header.SGList = 1;

-               c->Header.SGTotal= 1;
+               c->Header.SGTotal = 1;

        } else {
                c->Header.SGList = 0;
        } else {
                c->Header.SGList = 0;

-                c->Header.SGTotal= 0;
+               c->Header.SGTotal = 0;

        }
        c->Header.Tag.lower = c->busaddr;
 
        c->Request.Type.Type = cmd_type;
        if (cmd_type == TYPE_CMD) {
        }
        c->Header.Tag.lower = c->busaddr;
 
        c->Request.Type.Type = cmd_type;
        if (cmd_type == TYPE_CMD) {

-               switch(cmd) {
-               case  CISS_INQUIRY:
+               switch (cmd) {
+               case CISS_INQUIRY:

                        /* If the logical unit number is 0 then, this is going
                        /* If the logical unit number is 0 then, this is going

-                       to controller so It's a physical command
-                       mode = 0 target = 0.  So we have nothing to write.
-                       otherwise, if use_unit_num == 1,
-                       mode = 1(volume set addressing) target = LUNID
-                       otherwise, if use_unit_num == 2,
-                       mode = 0(periph dev addr) target = scsi3addr */
+                          to controller so It's a physical command
+                          mode = 0 target = 0.  So we have nothing to write.
+                          otherwise, if use_unit_num == 1,
+                          mode = 1(volume set addressing) target = LUNID
+                          otherwise, if use_unit_num == 2,
+                          mode = 0(periph dev addr) target = scsi3addr */

                        if (use_unit_num == 1) {
                        if (use_unit_num == 1) {

-                               c->Header.LUN.LogDev.VolId=
-                                       h->drv[log_unit].LunID;
-                               c->Header.LUN.LogDev.Mode = 1;
+                               c->Header.LUN.LogDev.VolId =
+                                   h->drv[log_unit].LunID;
+                               c->Header.LUN.LogDev.Mode = 1;

                        } else if (use_unit_num == 2) {
                        } else if (use_unit_num == 2) {

-                               memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8);
+                               memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
+                                      8);

                                c->Header.LUN.LogDev.Mode = 0;
                        }
                        /* are we trying to read a vital product page */
                                c->Header.LUN.LogDev.Mode = 0;
                        }
                        /* are we trying to read a vital product page */

-                       if(page_code != 0) {
+                       if (page_code != 0) {

                                c->Request.CDB[1] = 0x01;
                                c->Request.CDB[2] = page_code;
                        }
                        c->Request.CDBLen = 6;
                                c->Request.CDB[1] = 0x01;
                                c->Request.CDB[2] = page_code;
                        }
                        c->Request.CDBLen = 6;

-                       c->Request.Type.Attribute = ATTR_SIMPLE;  
+                       c->Request.Type.Attribute = ATTR_SIMPLE;

                        c->Request.Type.Direction = XFER_READ;
                        c->Request.Timeout = 0;
                        c->Request.Type.Direction = XFER_READ;
                        c->Request.Timeout = 0;

-                       c->Request.CDB[0] =  CISS_INQUIRY;
-                       c->Request.CDB[4] = size  & 0xFF;  
-               break;
+                       c->Request.CDB[0] = CISS_INQUIRY;
+                       c->Request.CDB[4] = size & 0xFF;
+                       break;

                case CISS_REPORT_LOG:
                case CISS_REPORT_PHYS:
                case CISS_REPORT_LOG:
                case CISS_REPORT_PHYS:

-                        /* Talking to controller so It's a physical command
+                       /* Talking to controller so It's a physical command

                           mode = 00 target = 0.  Nothing to write.
                           mode = 00 target = 0.  Nothing to write.

-                        */
+                        */

                        c->Request.CDBLen = 12;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                        c->Request.Type.Direction = XFER_READ;
                        c->Request.Timeout = 0;
                        c->Request.CDB[0] = cmd;
                        c->Request.CDBLen = 12;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                        c->Request.Type.Direction = XFER_READ;
                        c->Request.Timeout = 0;
                        c->Request.CDB[0] = cmd;

-                       c->Request.CDB[6] = (size >> 24) & 0xFF;  //MSB
+                       c->Request.CDB[6] = (size >> 24) & 0xFF;        //MSB

                        c->Request.CDB[7] = (size >> 16) & 0xFF;
                        c->Request.CDB[8] = (size >> 8) & 0xFF;
                        c->Request.CDB[9] = size & 0xFF;
                        c->Request.CDB[7] = (size >> 16) & 0xFF;
                        c->Request.CDB[8] = (size >> 8) & 0xFF;
                        c->Request.CDB[9] = size & 0xFF;


@@ -1635,7 +1691,23 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
                        c->Request.Type.Direction = XFER_READ;
                        c->Request.Timeout = 0;
                        c->Request.CDB[0] = cmd;
                        c->Request.Type.Direction = XFER_READ;
                        c->Request.Timeout = 0;
                        c->Request.CDB[0] = cmd;

-               break;
+                       break;
+               case CCISS_READ_CAPACITY_16:
+                       c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
+                       c->Header.LUN.LogDev.Mode = 1;
+                       c->Request.CDBLen = 16;
+                       c->Request.Type.Attribute = ATTR_SIMPLE;
+                       c->Request.Type.Direction = XFER_READ;
+                       c->Request.Timeout = 0;
+                       c->Request.CDB[0] = cmd;
+                       c->Request.CDB[1] = 0x10;
+                       c->Request.CDB[10] = (size >> 24) & 0xFF;
+                       c->Request.CDB[11] = (size >> 16) & 0xFF;
+                       c->Request.CDB[12] = (size >> 8) & 0xFF;
+                       c->Request.CDB[13] = size & 0xFF;
+                       c->Request.Timeout = 0;
+                       c->Request.CDB[0] = cmd;
+                       break;

                case CCISS_CACHE_FLUSH:
                        c->Request.CDBLen = 12;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                case CCISS_CACHE_FLUSH:
                        c->Request.CDBLen = 12;
                        c->Request.Type.Attribute = ATTR_SIMPLE;


@@ -1643,32 +1715,33 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
                        c->Request.Timeout = 0;
                        c->Request.CDB[0] = BMIC_WRITE;
                        c->Request.CDB[6] = BMIC_CACHE_FLUSH;
                        c->Request.Timeout = 0;
                        c->Request.CDB[0] = BMIC_WRITE;
                        c->Request.CDB[6] = BMIC_CACHE_FLUSH;

-               break;
+                       break;

                default:
                        printk(KERN_WARNING
                default:
                        printk(KERN_WARNING

-                               "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
-                       return(IO_ERROR);
+                              "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
+                       return IO_ERROR;

                }
        } else if (cmd_type == TYPE_MSG) {
                switch (cmd) {
                }
        } else if (cmd_type == TYPE_MSG) {
                switch (cmd) {

-               case 0: /* ABORT message */
+               case 0: /* ABORT message */

                        c->Request.CDBLen = 12;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                        c->Request.Type.Direction = XFER_WRITE;
                        c->Request.Timeout = 0;
                        c->Request.CDBLen = 12;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                        c->Request.Type.Direction = XFER_WRITE;
                        c->Request.Timeout = 0;

-                       c->Request.CDB[0] = cmd; /* abort */
-                       c->Request.CDB[1] = 0;   /* abort a command */
+                       c->Request.CDB[0] = cmd;        /* abort */
+                       c->Request.CDB[1] = 0;  /* abort a command */

                        /* buff contains the tag of the command to abort */
                        memcpy(&c->Request.CDB[4], buff, 8);
                        break;
                        /* buff contains the tag of the command to abort */
                        memcpy(&c->Request.CDB[4], buff, 8);
                        break;

-               case 1: /* RESET message */
+               case 1: /* RESET message */

                        c->Request.CDBLen = 12;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                        c->Request.Type.Direction = XFER_WRITE;
                        c->Request.Timeout = 0;
                        memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
                        c->Request.CDBLen = 12;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                        c->Request.Type.Direction = XFER_WRITE;
                        c->Request.Timeout = 0;
                        memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));

-                       c->Request.CDB[0] = cmd;  /* reset */
-                       c->Request.CDB[1] = 0x04; /* reset a LUN */
+                       c->Request.CDB[0] = cmd;        /* reset */
+                       c->Request.CDB[1] = 0x04;       /* reset a LUN */
+                       break;

                case 3: /* No-Op message */
                        c->Request.CDBLen = 1;
                        c->Request.Type.Attribute = ATTR_SIMPLE;
                case 3: /* No-Op message */
                        c->Request.CDBLen = 1;
                        c->Request.Type.Attribute = ATTR_SIMPLE;


@@ -1678,212 +1751,255 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
                        break;
                default:
                        printk(KERN_WARNING
                        break;
                default:
                        printk(KERN_WARNING

-                               "cciss%d: unknown message type %d\n",
-                               ctlr, cmd);
+                              "cciss%d: unknown message type %d\n", ctlr, cmd);

                        return IO_ERROR;
                }
        } else {
                printk(KERN_WARNING
                        return IO_ERROR;
                }
        } else {
                printk(KERN_WARNING

-                       "cciss%d: unknown command type %d\n", ctlr, cmd_type);
+                      "cciss%d: unknown command type %d\n", ctlr, cmd_type);

                return IO_ERROR;
        }
        /* Fill in the scatter gather information */
        if (size > 0) {
                buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
                return IO_ERROR;
        }
        /* Fill in the scatter gather information */
        if (size > 0) {
                buff_dma_handle.val = (__u64) pci_map_single(h->pdev,

-                       buff, size, PCI_DMA_BIDIRECTIONAL);
+                                                            buff, size,
+                                                            PCI_DMA_BIDIRECTIONAL);

                c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
                c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
                c->SG[0].Len = size;
                c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
                c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
                c->SG[0].Len = size;

-               c->SG[0].Ext = 0;  /* we are not chaining */
+               c->SG[0].Ext = 0;       /* we are not chaining */

        }
        return status;
 }
        }
        return status;
 }

-static int sendcmd_withirq(__u8        cmd,
-       int     ctlr,
-       void    *buff,
-       size_t  size,
-       unsigned int use_unit_num,
-       unsigned int log_unit,
-       __u8    page_code,
-       int cmd_type)
+
+static int sendcmd_withirq(__u8 cmd,
+                          int ctlr,
+                          void *buff,
+                          size_t size,
+                          unsigned int use_unit_num,
+                          unsigned int log_unit, __u8 page_code, int cmd_type)

 {
        ctlr_info_t *h = hba[ctlr];
        CommandList_struct *c;
 {
        ctlr_info_t *h = hba[ctlr];
        CommandList_struct *c;

-       u64bit  buff_dma_handle;
+       u64bit buff_dma_handle;

        unsigned long flags;
        int return_status;
        unsigned long flags;
        int return_status;

-       DECLARE_COMPLETION(wait);
-       
-       if ((c = cmd_alloc(h , 0)) == NULL)
+       DECLARE_COMPLETION_ONSTACK(wait);
+
+       if ((c = cmd_alloc(h, 0)) == NULL)

                return -ENOMEM;
        return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
                return -ENOMEM;
        return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,

-               log_unit, page_code, NULL, cmd_type);
+                                log_unit, page_code, NULL, cmd_type);

        if (return_status != IO_OK) {
                cmd_free(h, c, 0);
                return return_status;
        }
        if (return_status != IO_OK) {
                cmd_free(h, c, 0);
                return return_status;
        }

-resend_cmd2:
+      resend_cmd2:

        c->waiting = &wait;
        c->waiting = &wait;

-       
+

        /* Put the request on the tail of the queue and send it */
        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
        addQ(&h->reqQ, c);
        h->Qdepth++;
        start_io(h);
        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
        /* Put the request on the tail of the queue and send it */
        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
        addQ(&h->reqQ, c);
        h->Qdepth++;
        start_io(h);
        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);

-       
+

        wait_for_completion(&wait);
 
        wait_for_completion(&wait);
 

-       if(c->err_info->CommandStatus != 0) 
-       { /* an error has occurred */ 
-               switch(c->err_info->CommandStatus)
-               {
-                       case CMD_TARGET_STATUS:
-                               printk(KERN_WARNING "cciss: cmd %p has "
-                                       " completed with errors\n", c);
-                               if( c->err_info->ScsiStatus)
-                               {
-                                       printk(KERN_WARNING "cciss: cmd %p "
-                                       "has SCSI Status = %x\n",
-                                               c,  
-                                               c->err_info->ScsiStatus);
-                               }
+       if (c->err_info->CommandStatus != 0) {  /* an error has occurred */
+               switch (c->err_info->CommandStatus) {
+               case CMD_TARGET_STATUS:
+                       printk(KERN_WARNING "cciss: cmd %p has "
+                              " completed with errors\n", c);
+                       if (c->err_info->ScsiStatus) {
+                               printk(KERN_WARNING "cciss: cmd %p "
+                                      "has SCSI Status = %x\n",
+                                      c, c->err_info->ScsiStatus);
+                       }

 
                        break;
 
                        break;

-                       case CMD_DATA_UNDERRUN:
-                       case CMD_DATA_OVERRUN:
+               case CMD_DATA_UNDERRUN:
+               case CMD_DATA_OVERRUN:

                        /* expected for inquire and report lun commands */
                        break;
                        /* expected for inquire and report lun commands */
                        break;

-                       case CMD_INVALID:
-                               printk(KERN_WARNING "cciss: Cmd %p is "
-                                       "reported invalid\n", c);
-                               return_status = IO_ERROR;
+               case CMD_INVALID:
+                       printk(KERN_WARNING "cciss: Cmd %p is "
+                              "reported invalid\n", c);
+                       return_status = IO_ERROR;

                        break;
                        break;

-                       case CMD_PROTOCOL_ERR:
-                                printk(KERN_WARNING "cciss: cmd %p has "
-                                       "protocol error \n", c);
-                                return_status = IO_ERROR;
-                        break;
-case CMD_HARDWARE_ERR:
-                                printk(KERN_WARNING "cciss: cmd %p had " 
-                                        " hardware error\n", c);
-                                return_status = IO_ERROR;
-                        break;
-                       case CMD_CONNECTION_LOST:
-                               printk(KERN_WARNING "cciss: cmd %p had "
-                                       "connection lost\n", c);
-                               return_status = IO_ERROR;
+               case CMD_PROTOCOL_ERR:
+                       printk(KERN_WARNING "cciss: cmd %p has "
+                              "protocol error \n", c);
+                       return_status = IO_ERROR;

                        break;
                        break;

-                       case CMD_ABORTED:
-                               printk(KERN_WARNING "cciss: cmd %p was "
-                                       "aborted\n", c);
-                               return_status = IO_ERROR;
+               case CMD_HARDWARE_ERR:
+                       printk(KERN_WARNING "cciss: cmd %p had "
+                              " hardware error\n", c);
+                       return_status = IO_ERROR;

                        break;
                        break;

-                       case CMD_ABORT_FAILED:
-                               printk(KERN_WARNING "cciss: cmd %p reports "
-                                       "abort failed\n", c);
-                               return_status = IO_ERROR;
+               case CMD_CONNECTION_LOST:
+                       printk(KERN_WARNING "cciss: cmd %p had "
+                              "connection lost\n", c);
+                       return_status = IO_ERROR;

                        break;
                        break;

-                       case CMD_UNSOLICITED_ABORT:
-                               printk(KERN_WARNING 
-                                       "cciss%d: unsolicited abort %p\n",
-                                       ctlr, c);
-                               if (c->retry_count < MAX_CMD_RETRIES) {
-                                       printk(KERN_WARNING 
-                                               "cciss%d: retrying %p\n", 
-                                               ctlr, c);
-                                       c->retry_count++;
-                                       /* erase the old error information */
-                                       memset(c->err_info, 0,
-                                               sizeof(ErrorInfo_struct));
-                                       return_status = IO_OK;
-                                       INIT_COMPLETION(wait);
-                                       goto resend_cmd2;
-                               }
-                               return_status = IO_ERROR;
+               case CMD_ABORTED:
+                       printk(KERN_WARNING "cciss: cmd %p was "
+                              "aborted\n", c);
+                       return_status = IO_ERROR;

                        break;
                        break;

-                       default:
-                               printk(KERN_WARNING "cciss: cmd %p returned "
-                                       "unknown status %x\n", c, 
-                                               c->err_info->CommandStatus); 
-                               return_status = IO_ERROR;
+               case CMD_ABORT_FAILED:
+                       printk(KERN_WARNING "cciss: cmd %p reports "
+                              "abort failed\n", c);
+                       return_status = IO_ERROR;
+                       break;
+               case CMD_UNSOLICITED_ABORT:
+                       printk(KERN_WARNING
+                              "cciss%d: unsolicited abort %p\n", ctlr, c);
+                       if (c->retry_count < MAX_CMD_RETRIES) {
+                               printk(KERN_WARNING
+                                      "cciss%d: retrying %p\n", ctlr, c);
+                               c->retry_count++;
+                               /* erase the old error information */
+                               memset(c->err_info, 0,
+                                      sizeof(ErrorInfo_struct));
+                               return_status = IO_OK;
+                               INIT_COMPLETION(wait);
+                               goto resend_cmd2;
+                       }
+                       return_status = IO_ERROR;
+                       break;
+               default:
+                       printk(KERN_WARNING "cciss: cmd %p returned "
+                              "unknown status %x\n", c,
+                              c->err_info->CommandStatus);
+                       return_status = IO_ERROR;

                }
                }

-       }       
+       }

        /* unlock the buffers from DMA */
        buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
        buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
        /* unlock the buffers from DMA */
        buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
        buff_dma_handle.val32.upper = c->SG[0].Addr.upper;

-       pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val,
-                       c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
+       pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
+                        c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);

        cmd_free(h, c, 0);
        cmd_free(h, c, 0);

-        return(return_status);
-
+       return return_status;

 }
 }

+

 static void cciss_geometry_inquiry(int ctlr, int logvol,
 static void cciss_geometry_inquiry(int ctlr, int logvol,

-                       int withirq, unsigned int total_size,
-                       unsigned int block_size, InquiryData_struct *inq_buff,
-                       drive_info_struct *drv)
+                                  int withirq, sector_t total_size,
+                                  unsigned int block_size,
+                                  InquiryData_struct *inq_buff,
+                                  drive_info_struct *drv)

 {
        int return_code;
 {
        int return_code;

+       unsigned long t;
+

        memset(inq_buff, 0, sizeof(InquiryData_struct));
        if (withirq)
                return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
        memset(inq_buff, 0, sizeof(InquiryData_struct));
        if (withirq)
                return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,

-                       inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD);
+                                             inq_buff, sizeof(*inq_buff), 1,
+                                             logvol, 0xC1, TYPE_CMD);

        else
                return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
        else
                return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,

-                       sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD);
+                                     sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
+                                     TYPE_CMD);

        if (return_code == IO_OK) {
        if (return_code == IO_OK) {

-               if(inq_buff->data_byte[8] == 0xFF) {
+               if (inq_buff->data_byte[8] == 0xFF) {

                        printk(KERN_WARNING
                        printk(KERN_WARNING

-                               "cciss: reading geometry failed, volume "
-                               "does not support reading geometry\n");
-                       drv->block_size = block_size;
-                       drv->nr_blocks = total_size;
+                              "cciss: reading geometry failed, volume "
+                              "does not support reading geometry\n");

                        drv->heads = 255;
                        drv->heads = 255;

-                       drv->sectors = 32; // Sectors per track
-                       drv->cylinders = total_size / 255 / 32;
+                       drv->sectors = 32;      // Sectors per track
+                       drv->raid_level = RAID_UNKNOWN;

                } else {
                } else {

-                       unsigned int t;
-
-                       drv->block_size = block_size;
-                       drv->nr_blocks = total_size;

                        drv->heads = inq_buff->data_byte[6];
                        drv->sectors = inq_buff->data_byte[7];
                        drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
                        drv->cylinders += inq_buff->data_byte[5];
                        drv->raid_level = inq_buff->data_byte[8];
                        drv->heads = inq_buff->data_byte[6];
                        drv->sectors = inq_buff->data_byte[7];
                        drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
                        drv->cylinders += inq_buff->data_byte[5];
                        drv->raid_level = inq_buff->data_byte[8];

-                       t = drv->heads * drv->sectors;
-                       if (t > 1) {
-                               drv->cylinders = total_size/t;
-                       }

                }
                }

-       } else { /* Get geometry failed */
+               drv->block_size = block_size;
+               drv->nr_blocks = total_size;
+               t = drv->heads * drv->sectors;
+               if (t > 1) {
+                       unsigned rem = sector_div(total_size, t);
+                       if (rem)
+                               total_size++;
+                       drv->cylinders = total_size;
+               }
+       } else {                /* Get geometry failed */

                printk(KERN_WARNING "cciss: reading geometry failed\n");
        }
                printk(KERN_WARNING "cciss: reading geometry failed\n");
        }

-       printk(KERN_INFO "      heads= %d, sectors= %d, cylinders= %d\n\n",
-               drv->heads, drv->sectors, drv->cylinders);
+       printk(KERN_INFO "      heads=%d, sectors=%d, cylinders=%d\n\n",
+              drv->heads, drv->sectors, drv->cylinders);

 }
 }

+

 static void
 static void

-cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
-               int withirq, unsigned int *total_size, unsigned int *block_size)
+cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
+                   unsigned int *block_size)

 {
 {

+       ReadCapdata_struct *buf;

        int return_code;
        int return_code;

-       memset(buf, 0, sizeof(*buf));
+       buf = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
+       if (buf == NULL) {
+               printk(KERN_WARNING "cciss: out of memory\n");
+               return;
+       }
+       memset(buf, 0, sizeof(ReadCapdata_struct));

        if (withirq)
                return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
        if (withirq)
                return_code = sendcmd_withirq(CCISS_READ_CAPACITY,

-                       ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD);
+                               ctlr, buf, sizeof(ReadCapdata_struct),
+                                       1, logvol, 0, TYPE_CMD);

        else
                return_code = sendcmd(CCISS_READ_CAPACITY,
        else
                return_code = sendcmd(CCISS_READ_CAPACITY,

-                       ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD);
+                               ctlr, buf, sizeof(ReadCapdata_struct),
+                                       1, logvol, 0, NULL, TYPE_CMD);
+       if (return_code == IO_OK) {
+               *total_size = be32_to_cpu(*(__u32 *) buf->total_size)+1;
+               *block_size = be32_to_cpu(*(__u32 *) buf->block_size);
+       } else {                /* read capacity command failed */
+               printk(KERN_WARNING "cciss: read capacity failed\n");
+               *total_size = 0;
+               *block_size = BLOCK_SIZE;
+       }
+       if (*total_size != (__u32) 0)
+               printk(KERN_INFO "      blocks= %llu block_size= %d\n",
+               (unsigned long long)*total_size, *block_size);
+       kfree(buf);
+       return;
+}
+
+static void
+cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,                                unsigned int *block_size)
+{
+       ReadCapdata_struct_16 *buf;
+       int return_code;
+       buf = kmalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
+       if (buf == NULL) {
+               printk(KERN_WARNING "cciss: out of memory\n");
+               return;
+       }
+       memset(buf, 0, sizeof(ReadCapdata_struct_16));
+       if (withirq) {
+               return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
+                       ctlr, buf, sizeof(ReadCapdata_struct_16),
+                               1, logvol, 0, TYPE_CMD);
+       }
+       else {
+               return_code = sendcmd(CCISS_READ_CAPACITY_16,
+                       ctlr, buf, sizeof(ReadCapdata_struct_16),
+                               1, logvol, 0, NULL, TYPE_CMD);
+       }

        if (return_code == IO_OK) {
        if (return_code == IO_OK) {

-               *total_size = be32_to_cpu(*((__be32 *) &buf->total_size[0]))+1;
-               *block_size = be32_to_cpu(*((__be32 *) &buf->block_size[0]));
-       } else { /* read capacity command failed */
+               *total_size = be64_to_cpu(*(__u64 *) buf->total_size)+1;
+               *block_size = be32_to_cpu(*(__u32 *) buf->block_size);
+       } else {                /* read capacity command failed */

                printk(KERN_WARNING "cciss: read capacity failed\n");
                *total_size = 0;
                *block_size = BLOCK_SIZE;
        }
                printk(KERN_WARNING "cciss: read capacity failed\n");
                *total_size = 0;
                *block_size = BLOCK_SIZE;
        }

-       printk(KERN_INFO "      blocks= %u block_size= %d\n",
-               *total_size, *block_size);
+       printk(KERN_INFO "      blocks= %llu block_size= %d\n",
+              (unsigned long long)*total_size, *block_size);
+       kfree(buf);

        return;
 }
 
        return;
 }
 


@@ -1892,43 +2008,39 @@ static int cciss_revalidate(struct gendisk *disk)
        ctlr_info_t *h = get_host(disk);
        drive_info_struct *drv = get_drv(disk);
        int logvol;
        ctlr_info_t *h = get_host(disk);
        drive_info_struct *drv = get_drv(disk);
        int logvol;

-       int FOUND=0;
+       int FOUND = 0;

        unsigned int block_size;
        unsigned int block_size;

-       unsigned int total_size;
-       ReadCapdata_struct *size_buff = NULL;
+       sector_t total_size;

        InquiryData_struct *inq_buff = NULL;
 
        InquiryData_struct *inq_buff = NULL;
 

-       for(logvol=0; logvol < CISS_MAX_LUN; logvol++)
-       {
-               if(h->drv[logvol].LunID == drv->LunID) {
-                       FOUND=1;
+       for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
+               if (h->drv[logvol].LunID == drv->LunID) {
+                       FOUND = 1;

                        break;
                }
        }
 
                        break;
                }
        }
 

-       if (!FOUND) return 1;
-
-       size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
-        if (size_buff == NULL)
-        {
-                printk(KERN_WARNING "cciss: out of memory\n");
-                return 1;
-        }
-       inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
-        if (inq_buff == NULL)
-        {
-                printk(KERN_WARNING "cciss: out of memory\n");
-               kfree(size_buff);
-                return 1;
-        }
+       if (!FOUND)
+               return 1;

 
 

-       cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size, &block_size);
-       cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, inq_buff, drv);
+       inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
+       if (inq_buff == NULL) {
+               printk(KERN_WARNING "cciss: out of memory\n");
+               return 1;
+       }
+       if (h->cciss_read == CCISS_READ_10) {
+               cciss_read_capacity(h->ctlr, logvol, 1,
+                                       &total_size, &block_size);
+       } else {
+               cciss_read_capacity_16(h->ctlr, logvol, 1,
+                                       &total_size, &block_size);
+       }
+       cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
+                              inq_buff, drv);

 
        blk_queue_hardsect_size(drv->queue, drv->block_size);
        set_capacity(disk, drv->nr_blocks);
 
 
        blk_queue_hardsect_size(drv->queue, drv->block_size);
        set_capacity(disk, drv->nr_blocks);
 

-       kfree(size_buff);

        kfree(inq_buff);
        return 0;
 }
        kfree(inq_buff);
        return 0;
 }


@@ -1950,7 +2062,7 @@ static unsigned long pollcomplete(int ctlr)
                if (done == FIFO_EMPTY)
                        schedule_timeout_uninterruptible(1);
                else
                if (done == FIFO_EMPTY)
                        schedule_timeout_uninterruptible(1);
                else

-                       return (done);
+                       return done;

        }
        /* Invalid address to tell caller we ran out of time */
        return 1;
        }
        /* Invalid address to tell caller we ran out of time */
        return 1;


@@ -1959,28 +2071,28 @@ static unsigned long pollcomplete(int ctlr)
 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
 {
        /* We get in here if sendcmd() is polling for completions
 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
 {
        /* We get in here if sendcmd() is polling for completions

-          and gets some command back that it wasn't expecting -- 
-          something other than that which it just sent down.  
-          Ordinarily, that shouldn't happen, but it can happen when 
+          and gets some command back that it wasn't expecting --
+          something other than that which it just sent down.
+          Ordinarily, that shouldn't happen, but it can happen when

           the scsi tape stuff gets into error handling mode, and
           the scsi tape stuff gets into error handling mode, and

-          starts using sendcmd() to try to abort commands and 
+          starts using sendcmd() to try to abort commands and

           reset tape drives.  In that case, sendcmd may pick up
           completions of commands that were sent to logical drives
           reset tape drives.  In that case, sendcmd may pick up
           completions of commands that were sent to logical drives

-          through the block i/o system, or cciss ioctls completing, etc. 
+          through the block i/o system, or cciss ioctls completing, etc.

           In that case, we need to save those completions for later
           processing by the interrupt handler.
           In that case, we need to save those completions for later
           processing by the interrupt handler.

-       */
+        */

 
 #ifdef CONFIG_CISS_SCSI_TAPE
 
 #ifdef CONFIG_CISS_SCSI_TAPE

-       struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;     
+       struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;

 
        /* If it's not the scsi tape stuff doing error handling, (abort */
        /* or reset) then we don't expect anything weird. */
        if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
 #endif
 
        /* If it's not the scsi tape stuff doing error handling, (abort */
        /* or reset) then we don't expect anything weird. */
        if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
 #endif

-               printk( KERN_WARNING "cciss cciss%d: SendCmd "
-                     "Invalid command list address returned! (%lx)\n",
-                       ctlr, complete);
+               printk(KERN_WARNING "cciss cciss%d: SendCmd "
+                      "Invalid command list address returned! (%lx)\n",
+                      ctlr, complete);

                /* not much we can do. */
 #ifdef CONFIG_CISS_SCSI_TAPE
                return 1;
                /* not much we can do. */
 #ifdef CONFIG_CISS_SCSI_TAPE
                return 1;


@@ -1988,10 +2100,10 @@ static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
 
        /* We've sent down an abort or reset, but something else
           has completed */
 
        /* We've sent down an abort or reset, but something else
           has completed */

-       if (srl->ncompletions >= (NR_CMDS + 2)) {
+       if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {

                /* Uh oh.  No room to save it for later... */
                printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
                /* Uh oh.  No room to save it for later... */
                printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "

-                       "reject list overflow, command lost!\n", ctlr);
+                      "reject list overflow, command lost!\n", ctlr);

                return 1;
        }
        /* Save it for later */
                return 1;
        }
        /* Save it for later */


@@ -2002,354 +2114,343 @@ static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
 }
 
 /*
 }
 
 /*

- * Send a command to the controller, and wait for it to complete.  
- * Only used at init time. 
+ * Send a command to the controller, and wait for it to complete.
+ * Only used at init time.

  */
  */

-static int sendcmd(
-       __u8    cmd,
-       int     ctlr,
-       void    *buff,
-       size_t  size,
-       unsigned int use_unit_num, /* 0: address the controller,
-                                     1: address logical volume log_unit, 
-                                     2: periph device address is scsi3addr */
-       unsigned int log_unit,
-       __u8    page_code,
-       unsigned char *scsi3addr,
-       int cmd_type)
+static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,     /* 0: address the controller,
+                                                                                                  1: address logical volume log_unit,
+                                                                                                  2: periph device address is scsi3addr */
+                  unsigned int log_unit,
+                  __u8 page_code, unsigned char *scsi3addr, int cmd_type)

 {
        CommandList_struct *c;
        int i;
        unsigned long complete;
 {
        CommandList_struct *c;
        int i;
        unsigned long complete;

-       ctlr_info_t *info_p= hba[ctlr];
+       ctlr_info_t *info_p = hba[ctlr];

        u64bit buff_dma_handle;
        int status, done = 0;
 
        if ((c = cmd_alloc(info_p, 1)) == NULL) {
                printk(KERN_WARNING "cciss: unable to get memory");
        u64bit buff_dma_handle;
        int status, done = 0;
 
        if ((c = cmd_alloc(info_p, 1)) == NULL) {
                printk(KERN_WARNING "cciss: unable to get memory");

-               return(IO_ERROR);
+               return IO_ERROR;

        }
        status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
        }
        status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,

-               log_unit, page_code, scsi3addr, cmd_type);
+                         log_unit, page_code, scsi3addr, cmd_type);

        if (status != IO_OK) {
                cmd_free(info_p, c, 1);
                return status;
        }
        if (status != IO_OK) {
                cmd_free(info_p, c, 1);
                return status;
        }

-resend_cmd1:
+      resend_cmd1:

        /*
        /*

-         * Disable interrupt
-         */
+        * Disable interrupt
+        */

 #ifdef CCISS_DEBUG
        printk(KERN_DEBUG "cciss: turning intr off\n");
 #ifdef CCISS_DEBUG
        printk(KERN_DEBUG "cciss: turning intr off\n");

-#endif /* CCISS_DEBUG */ 
-        info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
-       
+#endif                         /* CCISS_DEBUG */
+       info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
+

        /* Make sure there is room in the command FIFO */
        /* Make sure there is room in the command FIFO */

-        /* Actually it should be completely empty at this time */
+       /* Actually it should be completely empty at this time */

        /* unless we are in here doing error handling for the scsi */
        /* tape side of the driver. */
        /* unless we are in here doing error handling for the scsi */
        /* tape side of the driver. */

-        for (i = 200000; i > 0; i--) 
-       {
+       for (i = 200000; i > 0; i--) {

                /* if fifo isn't full go */
                /* if fifo isn't full go */

-                if (!(info_p->access.fifo_full(info_p))) 
-               {
-                       
-                        break;
-                }
-                udelay(10);
-                printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
-                        " waiting!\n", ctlr);
-        }
-        /*
-         * Send the cmd
-         */
-        info_p->access.submit_command(info_p, c);
+               if (!(info_p->access.fifo_full(info_p))) {
+
+                       break;
+               }
+               udelay(10);
+               printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
+                      " waiting!\n", ctlr);
+       }
+       /*
+        * Send the cmd
+        */
+       info_p->access.submit_command(info_p, c);

        done = 0;
        do {
                complete = pollcomplete(ctlr);
 
 #ifdef CCISS_DEBUG
                printk(KERN_DEBUG "cciss: command completed\n");
        done = 0;
        do {
                complete = pollcomplete(ctlr);
 
 #ifdef CCISS_DEBUG
                printk(KERN_DEBUG "cciss: command completed\n");

-#endif /* CCISS_DEBUG */
+#endif                         /* CCISS_DEBUG */

 
                if (complete == 1) {
 
                if (complete == 1) {

-                       printk( KERN_WARNING
-                               "cciss cciss%d: SendCmd Timeout out, "
-                               "No command list address returned!\n",
-                               ctlr);
+                       printk(KERN_WARNING
+                              "cciss cciss%d: SendCmd Timeout out, "
+                              "No command list address returned!\n", ctlr);

                        status = IO_ERROR;
                        done = 1;
                        break;
                }
 
                /* This will need to change for direct lookup completions */
                        status = IO_ERROR;
                        done = 1;
                        break;
                }
 
                /* This will need to change for direct lookup completions */

-               if ( (complete & CISS_ERROR_BIT)
-                    && (complete & ~CISS_ERROR_BIT) == c->busaddr)
-                    {
-                       /* if data overrun or underun on Report command 
-                               ignore it 
-                       */
+               if ((complete & CISS_ERROR_BIT)
+                   && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
+                       /* if data overrun or underun on Report command
+                          ignore it
+                        */

                        if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
                             (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
                             (c->Request.CDB[0] == CISS_INQUIRY)) &&
                        if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
                             (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
                             (c->Request.CDB[0] == CISS_INQUIRY)) &&

-                               ((c->err_info->CommandStatus == 
-                                       CMD_DATA_OVERRUN) || 
-                                (c->err_info->CommandStatus == 
-                                       CMD_DATA_UNDERRUN)
-                               ))
-                       {
+                           ((c->err_info->CommandStatus ==
+                             CMD_DATA_OVERRUN) ||
+                            (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
+                           )) {

                                complete = c->busaddr;
                        } else {
                                if (c->err_info->CommandStatus ==
                                complete = c->busaddr;
                        } else {
                                if (c->err_info->CommandStatus ==

-                                               CMD_UNSOLICITED_ABORT) {
+                                   CMD_UNSOLICITED_ABORT) {

                                        printk(KERN_WARNING "cciss%d: "
                                        printk(KERN_WARNING "cciss%d: "

-                                               "unsolicited abort %p\n",
-                                               ctlr, c);
+                                              "unsolicited abort %p\n",
+                                              ctlr, c);

                                        if (c->retry_count < MAX_CMD_RETRIES) {
                                                printk(KERN_WARNING
                                        if (c->retry_count < MAX_CMD_RETRIES) {
                                                printk(KERN_WARNING

-                                                  "cciss%d: retrying %p\n",
-                                                  ctlr, c);
+                                                      "cciss%d: retrying %p\n",
+                                                      ctlr, c);

                                                c->retry_count++;
                                                /* erase the old error */
                                                /* information */
                                                memset(c->err_info, 0,
                                                c->retry_count++;
                                                /* erase the old error */
                                                /* information */
                                                memset(c->err_info, 0,

-                                                  sizeof(ErrorInfo_struct));
+                                                      sizeof
+                                                      (ErrorInfo_struct));

                                                goto resend_cmd1;
                                        } else {
                                                printk(KERN_WARNING
                                                goto resend_cmd1;
                                        } else {
                                                printk(KERN_WARNING

-                                                  "cciss%d: retried %p too "
-                                                  "many times\n", ctlr, c);
+                                                      "cciss%d: retried %p too "
+                                                      "many times\n", ctlr, c);

                                                status = IO_ERROR;
                                                goto cleanup1;
                                        }
                                                status = IO_ERROR;
                                                goto cleanup1;
                                        }

-                               } else if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
-                                       printk(KERN_WARNING "cciss%d: command could not be aborted.\n", ctlr);
+                               } else if (c->err_info->CommandStatus ==
+                                          CMD_UNABORTABLE) {
+                                       printk(KERN_WARNING
+                                              "cciss%d: command could not be aborted.\n",
+                                              ctlr);

                                        status = IO_ERROR;
                                        goto cleanup1;
                                }
                                printk(KERN_WARNING "ciss ciss%d: sendcmd"
                                        status = IO_ERROR;
                                        goto cleanup1;
                                }
                                printk(KERN_WARNING "ciss ciss%d: sendcmd"

-                               " Error %x \n", ctlr, 
-                                       c->err_info->CommandStatus); 
+                                      " Error %x \n", ctlr,
+                                      c->err_info->CommandStatus);

                                printk(KERN_WARNING "ciss ciss%d: sendcmd"
                                printk(KERN_WARNING "ciss ciss%d: sendcmd"

-                               " offensive info\n"
-                               "  size %x\n   num %x   value %x\n", ctlr,
-                                 c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
-                                 c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
-                                 c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
+                                      " offensive info\n"
+                                      "  size %x\n   num %x   value %x\n",
+                                      ctlr,
+                                      c->err_info->MoreErrInfo.Invalid_Cmd.
+                                      offense_size,
+                                      c->err_info->MoreErrInfo.Invalid_Cmd.
+                                      offense_num,
+                                      c->err_info->MoreErrInfo.Invalid_Cmd.
+                                      offense_value);

                                status = IO_ERROR;
                                goto cleanup1;
                        }
                }
                /* This will need changing for direct lookup completions */
                                status = IO_ERROR;
                                goto cleanup1;
                        }
                }
                /* This will need changing for direct lookup completions */

-                if (complete != c->busaddr) {
+               if (complete != c->busaddr) {

                        if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
                        if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {

-                               BUG(); /* we are pretty much hosed if we get here. */
+                               BUG();  /* we are pretty much hosed if we get here. */

                        }
                        continue;
                        }
                        continue;

-                } else
+               } else

                        done = 1;
                        done = 1;

-        } while (!done);
-               
-cleanup1:      
+       } while (!done);
+
+      cleanup1:

        /* unlock the data buffer from DMA */
        buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
        buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
        pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
        /* unlock the data buffer from DMA */
        buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
        buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
        pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,

-                               c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
+                        c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);

 #ifdef CONFIG_CISS_SCSI_TAPE
        /* if we saved some commands for later, process them now. */
        if (info_p->scsi_rejects.ncompletions > 0)
 #ifdef CONFIG_CISS_SCSI_TAPE
        /* if we saved some commands for later, process them now. */
        if (info_p->scsi_rejects.ncompletions > 0)

-               do_cciss_intr(0, info_p, NULL);
+               do_cciss_intr(0, info_p);

 #endif
        cmd_free(info_p, c, 1);
 #endif
        cmd_free(info_p, c, 1);

-       return (status);
-} 
+       return status;
+}
+

 /*
  * Map (physical) PCI mem into (virtual) kernel space
  */
 static void __iomem *remap_pci_mem(ulong base, ulong size)
 {
 /*
  * Map (physical) PCI mem into (virtual) kernel space
  */
 static void __iomem *remap_pci_mem(ulong base, ulong size)
 {

-        ulong page_base        = ((ulong) base) & PAGE_MASK;
-        ulong page_offs        = ((ulong) base) - page_base;
-        void __iomem *page_remapped = ioremap(page_base, page_offs+size);
+       ulong page_base = ((ulong) base) & PAGE_MASK;
+       ulong page_offs = ((ulong) base) - page_base;
+       void __iomem *page_remapped = ioremap(page_base, page_offs + size);

 
 

-        return page_remapped ? (page_remapped + page_offs) : NULL;
+       return page_remapped ? (page_remapped + page_offs) : NULL;

 }
 
 }
 

-/* 
- * Takes jobs of the Q and sends them to the hardware, then puts it on 
- * the Q to wait for completion. 
- */ 
-static void start_io( ctlr_info_t *h)
+/*
+ * Takes jobs of the Q and sends them to the hardware, then puts it on
+ * the Q to wait for completion.
+ */
+static void start_io(ctlr_info_t *h)

 {
        CommandList_struct *c;
 {
        CommandList_struct *c;

-       
-       while(( c = h->reqQ) != NULL )
-       {
+
+       while ((c = h->reqQ) != NULL) {

                /* can't do anything if fifo is full */
                if ((h->access.fifo_full(h))) {
                        printk(KERN_WARNING "cciss: fifo full\n");
                        break;
                }
 
                /* can't do anything if fifo is full */
                if ((h->access.fifo_full(h))) {
                        printk(KERN_WARNING "cciss: fifo full\n");
                        break;
                }
 

-               /* Get the frist entry from the Request Q */ 
+               /* Get the first entry from the Request Q */

                removeQ(&(h->reqQ), c);
                h->Qdepth--;
                removeQ(&(h->reqQ), c);
                h->Qdepth--;

-       
-               /* Tell the controller execute command */ 
+
+               /* Tell the controller execute command */

                h->access.submit_command(h, c);
                h->access.submit_command(h, c);

-               
-               /* Put job onto the completed Q */ 
-               addQ (&(h->cmpQ), c); 
+
+               /* Put job onto the completed Q */
+               addQ(&(h->cmpQ), c);

        }
 }
        }
 }

+

 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
 /* Zeros out the error record and then resends the command back */
 /* to the controller */
 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
 /* Zeros out the error record and then resends the command back */
 /* to the controller */

-static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c)
+static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)

 {
        /* erase the old error information */
        memset(c->err_info, 0, sizeof(ErrorInfo_struct));
 
        /* add it to software queue and then send it to the controller */
 {
        /* erase the old error information */
        memset(c->err_info, 0, sizeof(ErrorInfo_struct));
 
        /* add it to software queue and then send it to the controller */

-       addQ(&(h->reqQ),c);
+       addQ(&(h->reqQ), c);

        h->Qdepth++;
        h->Qdepth++;

-       if(h->Qdepth > h->maxQsinceinit)
+       if (h->Qdepth > h->maxQsinceinit)

                h->maxQsinceinit = h->Qdepth;
 
        start_io(h);
 }
 
                h->maxQsinceinit = h->Qdepth;
 
        start_io(h);
 }
 

-/* checks the status of the job and calls complete buffers to mark all 
+/* checks the status of the job and calls complete buffers to mark all

  * buffers for the completed job. Note that this function does not need
  * to hold the hba/queue lock.
  * buffers for the completed job. Note that this function does not need
  * to hold the hba/queue lock.

- */ 
-static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
-               int timeout)
+ */
+static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
+                                   int timeout)

 {
        int status = 1;
        int retry_cmd = 0;
 {
        int status = 1;
        int retry_cmd = 0;

-               
+

        if (timeout)
        if (timeout)

-               status = 0; 
+               status = 0;

 
 

-       if(cmd->err_info->CommandStatus != 0) 
-       { /* an error has occurred */ 
-               switch(cmd->err_info->CommandStatus)
-               {
+       if (cmd->err_info->CommandStatus != 0) {        /* an error has occurred */
+               switch (cmd->err_info->CommandStatus) {

                        unsigned char sense_key;
                        unsigned char sense_key;

-                       case CMD_TARGET_STATUS:
-                               status = 0;
-                       
-                               if( cmd->err_info->ScsiStatus == 0x02)
-                               {
-                                       printk(KERN_WARNING "cciss: cmd %p "
-                                               "has CHECK CONDITION "
-                                               " byte 2 = 0x%x\n", cmd,
-                                               cmd->err_info->SenseInfo[2]
-                                       );
-                                       /* check the sense key */
-                                       sense_key = 0xf & 
-                                               cmd->err_info->SenseInfo[2];
-                                       /* no status or recovered error */
-                                       if((sense_key == 0x0) ||
-                                           (sense_key == 0x1))
-                                       {
-                                                       status = 1;
-                                       }
-                               } else
-                               {
-                                       printk(KERN_WARNING "cciss: cmd %p "
-                                                "has SCSI Status 0x%x\n",
-                                               cmd, cmd->err_info->ScsiStatus);
+               case CMD_TARGET_STATUS:
+                       status = 0;
+
+                       if (cmd->err_info->ScsiStatus == 0x02) {
+                               printk(KERN_WARNING "cciss: cmd %p "
+                                      "has CHECK CONDITION "
+                                      " byte 2 = 0x%x\n", cmd,
+                                      cmd->err_info->SenseInfo[2]
+                                   );
+                               /* check the sense key */
+                               sense_key = 0xf & cmd->err_info->SenseInfo[2];
+                               /* no status or recovered error */
+                               if ((sense_key == 0x0) || (sense_key == 0x1)) {
+                                       status = 1;

                                }
                                }

+                       } else {
+                               printk(KERN_WARNING "cciss: cmd %p "
+                                      "has SCSI Status 0x%x\n",
+                                      cmd, cmd->err_info->ScsiStatus);
+                       }

                        break;
                        break;

-                       case CMD_DATA_UNDERRUN:
-                               printk(KERN_WARNING "cciss: cmd %p has"
-                                       " completed with data underrun "
-                                       "reported\n", cmd);
+               case CMD_DATA_UNDERRUN:
+                       printk(KERN_WARNING "cciss: cmd %p has"
+                              " completed with data underrun "
+                              "reported\n", cmd);

                        break;
                        break;

-                       case CMD_DATA_OVERRUN:
-                               printk(KERN_WARNING "cciss: cmd %p has"
-                                       " completed with data overrun "
-                                       "reported\n", cmd);
+               case CMD_DATA_OVERRUN:
+                       printk(KERN_WARNING "cciss: cmd %p has"
+                              " completed with data overrun "
+                              "reported\n", cmd);

                        break;
                        break;

-                       case CMD_INVALID:
-                               printk(KERN_WARNING "cciss: cmd %p is "
-                                       "reported invalid\n", cmd);
-                               status = 0;
+               case CMD_INVALID:
+                       printk(KERN_WARNING "cciss: cmd %p is "
+                              "reported invalid\n", cmd);
+                       status = 0;

                        break;
                        break;

-                       case CMD_PROTOCOL_ERR:
-                                printk(KERN_WARNING "cciss: cmd %p has "
-                                       "protocol error \n", cmd);
-                                status = 0;
-                        break;
-                       case CMD_HARDWARE_ERR:
-                                printk(KERN_WARNING "cciss: cmd %p had " 
-                                        " hardware error\n", cmd);
-                                status = 0;
-                        break;
-                       case CMD_CONNECTION_LOST:
-                               printk(KERN_WARNING "cciss: cmd %p had "
-                                       "connection lost\n", cmd);
-                               status=0;
+               case CMD_PROTOCOL_ERR:
+                       printk(KERN_WARNING "cciss: cmd %p has "
+                              "protocol error \n", cmd);
+                       status = 0;

                        break;
                        break;

-                       case CMD_ABORTED:
-                               printk(KERN_WARNING "cciss: cmd %p was "
-                                       "aborted\n", cmd);
-                               status=0;
+               case CMD_HARDWARE_ERR:
+                       printk(KERN_WARNING "cciss: cmd %p had "
+                              " hardware error\n", cmd);
+                       status = 0;

                        break;
                        break;

-                       case CMD_ABORT_FAILED:
-                               printk(KERN_WARNING "cciss: cmd %p reports "
-                                       "abort failed\n", cmd);
-                               status=0;
+               case CMD_CONNECTION_LOST:
+                       printk(KERN_WARNING "cciss: cmd %p had "
+                              "connection lost\n", cmd);
+                       status = 0;

                        break;
                        break;

-                       case CMD_UNSOLICITED_ABORT:
-                               printk(KERN_WARNING "cciss%d: unsolicited "
-                                       "abort %p\n", h->ctlr, cmd);
-                               if (cmd->retry_count < MAX_CMD_RETRIES) {
-                                       retry_cmd=1;
-                                       printk(KERN_WARNING
-                                               "cciss%d: retrying %p\n",
-                                               h->ctlr, cmd);
-                                       cmd->retry_count++;
-                               } else
-                                       printk(KERN_WARNING
-                                               "cciss%d: %p retried too "
-                                               "many times\n", h->ctlr, cmd);
-                               status=0;
+               case CMD_ABORTED:
+                       printk(KERN_WARNING "cciss: cmd %p was "
+                              "aborted\n", cmd);
+                       status = 0;
+                       break;
+               case CMD_ABORT_FAILED:
+                       printk(KERN_WARNING "cciss: cmd %p reports "
+                              "abort failed\n", cmd);
+                       status = 0;

                        break;
                        break;

-                       case CMD_TIMEOUT:
-                               printk(KERN_WARNING "cciss: cmd %p timedout\n",
-                                       cmd);
-                               status=0;
+               case CMD_UNSOLICITED_ABORT:
+                       printk(KERN_WARNING "cciss%d: unsolicited "
+                              "abort %p\n", h->ctlr, cmd);
+                       if (cmd->retry_count < MAX_CMD_RETRIES) {
+                               retry_cmd = 1;
+                               printk(KERN_WARNING
+                                      "cciss%d: retrying %p\n", h->ctlr, cmd);
+                               cmd->retry_count++;
+                       } else
+                               printk(KERN_WARNING
+                                      "cciss%d: %p retried too "
+                                      "many times\n", h->ctlr, cmd);
+                       status = 0;

                        break;
                        break;

-                       default:
-                               printk(KERN_WARNING "cciss: cmd %p returned "
-                                       "unknown status %x\n", cmd, 
-                                               cmd->err_info->CommandStatus); 
-                               status=0;
+               case CMD_TIMEOUT:
+                       printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
+                       status = 0;
+                       break;
+               default:
+                       printk(KERN_WARNING "cciss: cmd %p returned "
+                              "unknown status %x\n", cmd,
+                              cmd->err_info->CommandStatus);
+                       status = 0;

                }
        }
        /* We need to return this command */
                }
        }
        /* We need to return this command */

-       if(retry_cmd) {
-               resend_cciss_cmd(h,cmd);
+       if (retry_cmd) {
+               resend_cciss_cmd(h, cmd);

                return;
                return;

-       }       
+       }

 
        cmd->rq->completion_data = cmd;
        cmd->rq->errors = status;
 
        cmd->rq->completion_data = cmd;
        cmd->rq->errors = status;

+       blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);

        blk_complete_request(cmd->rq);
 }
 
        blk_complete_request(cmd->rq);
 }
 

-/* 
- * Get a request and submit it to the controller. 
+/*
+ * Get a request and submit it to the controller.

  */
 static void do_cciss_request(request_queue_t *q)
 {
  */
 static void do_cciss_request(request_queue_t *q)
 {

-       ctlr_info_t *h= q->queuedata; 
+       ctlr_info_t *h = q->queuedata;

        CommandList_struct *c;
        CommandList_struct *c;

-       int start_blk, seg;
+       sector_t start_blk;
+       int seg;

        struct request *creq;
        u64bit temp64;
        struct scatterlist tmp_sg[MAXSGENTRIES];
        struct request *creq;
        u64bit temp64;
        struct scatterlist tmp_sg[MAXSGENTRIES];


@@ -2358,19 +2459,18 @@ static void do_cciss_request(request_queue_t *q)
 
        /* We call start_io here in case there is a command waiting on the
         * queue that has not been sent.
 
        /* We call start_io here in case there is a command waiting on the
         * queue that has not been sent.

-       */
+        */

        if (blk_queue_plugged(q))
                goto startio;
 
        if (blk_queue_plugged(q))
                goto startio;
 

-queue:
+      queue:

        creq = elv_next_request(q);
        if (!creq)
                goto startio;
 
        creq = elv_next_request(q);
        if (!creq)
                goto startio;
 

-       if (creq->nr_phys_segments > MAXSGENTRIES)
-                BUG();
+       BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);

 
 

-       if (( c = cmd_alloc(h, 1)) == NULL)
+       if ((c = cmd_alloc(h, 1)) == NULL)

                goto full;
 
        blkdev_dequeue_request(creq);
                goto full;
 
        blkdev_dequeue_request(creq);


@@ -2379,73 +2479,92 @@ queue:
 
        c->cmd_type = CMD_RWREQ;
        c->rq = creq;
 
        c->cmd_type = CMD_RWREQ;
        c->rq = creq;

-       
-       /* fill in the request */ 
+
+       /* fill in the request */

        drv = creq->rq_disk->private_data;
        drv = creq->rq_disk->private_data;

-       c->Header.ReplyQueue = 0;  // unused in simple mode
+       c->Header.ReplyQueue = 0;       // unused in simple mode

        /* got command from pool, so use the command block index instead */
        /* for direct lookups. */
        /* The first 2 bits are reserved for controller error reporting. */
        c->Header.Tag.lower = (c->cmdindex << 3);
        /* got command from pool, so use the command block index instead */
        /* for direct lookups. */
        /* The first 2 bits are reserved for controller error reporting. */
        c->Header.Tag.lower = (c->cmdindex << 3);

-       c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
-       c->Header.LUN.LogDev.VolId= drv->LunID;
+       c->Header.Tag.lower |= 0x04;    /* flag for direct lookup. */
+       c->Header.LUN.LogDev.VolId = drv->LunID;

        c->Header.LUN.LogDev.Mode = 1;
        c->Header.LUN.LogDev.Mode = 1;

-       c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
-       c->Request.Type.Type =  TYPE_CMD; // It is a command. 
-       c->Request.Type.Attribute = ATTR_SIMPLE; 
-       c->Request.Type.Direction = 
-               (rq_data_dir(creq) == READ) ? XFER_READ: XFER_WRITE; 
-       c->Request.Timeout = 0; // Don't time out       
-       c->Request.CDB[0] = (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
+       c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
+       c->Request.Type.Type = TYPE_CMD;        // It is a command.
+       c->Request.Type.Attribute = ATTR_SIMPLE;
+       c->Request.Type.Direction =
+           (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
+       c->Request.Timeout = 0; // Don't time out
+       c->Request.CDB[0] =
+           (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;

        start_blk = creq->sector;
 #ifdef CCISS_DEBUG
        start_blk = creq->sector;
 #ifdef CCISS_DEBUG

-       printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",(int) creq->sector,
-               (int) creq->nr_sectors);        
-#endif /* CCISS_DEBUG */
+       printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
+              (int)creq->nr_sectors);
+#endif                         /* CCISS_DEBUG */

 
        seg = blk_rq_map_sg(q, creq, tmp_sg);
 
 
        seg = blk_rq_map_sg(q, creq, tmp_sg);
 

-       /* get the DMA records for the setup */ 
+       /* get the DMA records for the setup */

        if (c->Request.Type.Direction == XFER_READ)
                dir = PCI_DMA_FROMDEVICE;
        else
                dir = PCI_DMA_TODEVICE;
 
        if (c->Request.Type.Direction == XFER_READ)
                dir = PCI_DMA_FROMDEVICE;
        else
                dir = PCI_DMA_TODEVICE;
 

-       for (i=0; i<seg; i++)
-       {
+       for (i = 0; i < seg; i++) {

                c->SG[i].Len = tmp_sg[i].length;
                temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
                c->SG[i].Len = tmp_sg[i].length;
                temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,

-                                         tmp_sg[i].offset, tmp_sg[i].length,
-                                         dir);
+                                                 tmp_sg[i].offset,
+                                                 tmp_sg[i].length, dir);

                c->SG[i].Addr.lower = temp64.val32.lower;
                c->SG[i].Addr.lower = temp64.val32.lower;

-                c->SG[i].Addr.upper = temp64.val32.upper;
-                c->SG[i].Ext = 0;  // we are not chaining
+               c->SG[i].Addr.upper = temp64.val32.upper;
+               c->SG[i].Ext = 0;       // we are not chaining

        }
        }

-       /* track how many SG entries we are using */ 
-       if( seg > h->maxSG)
-               h->maxSG = seg; 
+       /* track how many SG entries we are using */
+       if (seg > h->maxSG)
+               h->maxSG = seg;

 
 #ifdef CCISS_DEBUG
 
 #ifdef CCISS_DEBUG

-       printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n", creq->nr_sectors, seg);
-#endif /* CCISS_DEBUG */
+       printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
+              creq->nr_sectors, seg);
+#endif                         /* CCISS_DEBUG */

 
        c->Header.SGList = c->Header.SGTotal = seg;
 
        c->Header.SGList = c->Header.SGTotal = seg;

-       c->Request.CDB[1]= 0;
-       c->Request.CDB[2]= (start_blk >> 24) & 0xff;    //MSB
-       c->Request.CDB[3]= (start_blk >> 16) & 0xff;
-       c->Request.CDB[4]= (start_blk >>  8) & 0xff;
-       c->Request.CDB[5]= start_blk & 0xff;
-       c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
-       c->Request.CDB[7]= (creq->nr_sectors >>  8) & 0xff; 
-       c->Request.CDB[8]= creq->nr_sectors & 0xff; 
-       c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
+       if(h->cciss_read == CCISS_READ_10) {
+               c->Request.CDB[1] = 0;
+               c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
+               c->Request.CDB[3] = (start_blk >> 16) & 0xff;
+               c->Request.CDB[4] = (start_blk >> 8) & 0xff;
+               c->Request.CDB[5] = start_blk & 0xff;
+               c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
+               c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
+               c->Request.CDB[8] = creq->nr_sectors & 0xff;
+               c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
+       } else {
+               c->Request.CDBLen = 16;
+               c->Request.CDB[1]= 0;
+               c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
+               c->Request.CDB[3]= (start_blk >> 48) & 0xff;
+               c->Request.CDB[4]= (start_blk >> 40) & 0xff;
+               c->Request.CDB[5]= (start_blk >> 32) & 0xff;
+               c->Request.CDB[6]= (start_blk >> 24) & 0xff;
+               c->Request.CDB[7]= (start_blk >> 16) & 0xff;
+               c->Request.CDB[8]= (start_blk >>  8) & 0xff;
+               c->Request.CDB[9]= start_blk & 0xff;
+               c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
+               c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
+               c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
+               c->Request.CDB[13]= creq->nr_sectors & 0xff;
+               c->Request.CDB[14] = c->Request.CDB[15] = 0;
+       }

 
        spin_lock_irq(q->queue_lock);
 
 
        spin_lock_irq(q->queue_lock);
 

-       addQ(&(h->reqQ),c);
+       addQ(&(h->reqQ), c);

        h->Qdepth++;
        h->Qdepth++;

-       if(h->Qdepth > h->maxQsinceinit)
-               h->maxQsinceinit = h->Qdepth; 
+       if (h->Qdepth > h->maxQsinceinit)
+               h->maxQsinceinit = h->Qdepth;

 
        goto queue;
 full:
 
        goto queue;
 full:


@@ -2453,7 +2572,7 @@ full:
 startio:
        /* We will already have the driver lock here so not need
         * to lock it.
 startio:
        /* We will already have the driver lock here so not need
         * to lock it.

-       */
+        */

        start_io(h);
 }
 
        start_io(h);
 }
 


@@ -2480,7 +2599,7 @@ static inline unsigned long get_next_completion(ctlr_info_t *h)
 static inline int interrupt_pending(ctlr_info_t *h)
 {
 #ifdef CONFIG_CISS_SCSI_TAPE
 static inline int interrupt_pending(ctlr_info_t *h)
 {
 #ifdef CONFIG_CISS_SCSI_TAPE

-       return ( h->access.intr_pending(h) 
+       return (h->access.intr_pending(h)

                || (h->scsi_rejects.ncompletions > 0));
 #else
        return h->access.intr_pending(h);
                || (h->scsi_rejects.ncompletions > 0));
 #else
        return h->access.intr_pending(h);


@@ -2490,23 +2609,21 @@ static inline int interrupt_pending(ctlr_info_t *h)
 static inline long interrupt_not_for_us(ctlr_info_t *h)
 {
 #ifdef CONFIG_CISS_SCSI_TAPE
 static inline long interrupt_not_for_us(ctlr_info_t *h)
 {
 #ifdef CONFIG_CISS_SCSI_TAPE

-       return (((h->access.intr_pending(h) == 0) || 
-                (h->interrupts_enabled == 0)) 
-             && (h->scsi_rejects.ncompletions == 0));
+       return (((h->access.intr_pending(h) == 0) ||
+                (h->interrupts_enabled == 0))
+               && (h->scsi_rejects.ncompletions == 0));

 #else
 #else

-       return (((h->access.intr_pending(h) == 0) || 
+       return (((h->access.intr_pending(h) == 0) ||

                 (h->interrupts_enabled == 0)));
 #endif
 }
 
                 (h->interrupts_enabled == 0)));
 #endif
 }
 

-static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t do_cciss_intr(int irq, void *dev_id)

 {
        ctlr_info_t *h = dev_id;
        CommandList_struct *c;
        unsigned long flags;
        __u32 a, a1, a2;
 {
        ctlr_info_t *h = dev_id;
        CommandList_struct *c;
        unsigned long flags;
        __u32 a, a1, a2;

-       int j;
-       int start_queue = h->next_to_run;

 
        if (interrupt_not_for_us(h))
                return IRQ_NONE;
 
        if (interrupt_not_for_us(h))
                return IRQ_NONE;


@@ -2516,12 +2633,14 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
         */
        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
        while (interrupt_pending(h)) {
         */
        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
        while (interrupt_pending(h)) {

-               while((a = get_next_completion(h)) != FIFO_EMPTY) {
+               while ((a = get_next_completion(h)) != FIFO_EMPTY) {

                        a1 = a;
                        if ((a & 0x04)) {
                                a2 = (a >> 3);
                        a1 = a;
                        if ((a & 0x04)) {
                                a2 = (a >> 3);

-                               if (a2 >= NR_CMDS) {
-                                       printk(KERN_WARNING "cciss: controller cciss%d failed, stopping.\n", h->ctlr);
+                               if (a2 >= h->nr_cmds) {
+                                       printk(KERN_WARNING
+                                              "cciss: controller cciss%d failed, stopping.\n",
+                                              h->ctlr);

                                        fail_all_cmds(h->ctlr);
                                        return IRQ_HANDLED;
                                }
                                        fail_all_cmds(h->ctlr);
                                        return IRQ_HANDLED;
                                }


@@ -2530,22 +2649,24 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
                                a = c->busaddr;
 
                        } else {
                                a = c->busaddr;
 
                        } else {

-                       a &= ~3;
+                               a &= ~3;

                                if ((c = h->cmpQ) == NULL) {
                                if ((c = h->cmpQ) == NULL) {

-                                       printk(KERN_WARNING "cciss: Completion of %08x ignored\n", a1);
-                               continue;       
-                       } 
-                       while(c->busaddr != a) {
-                               c = c->next;
-                               if (c == h->cmpQ) 
-                                       break;
-                       }
+                                       printk(KERN_WARNING
+                                              "cciss: Completion of %08x ignored\n",
+                                              a1);
+                                       continue;
+                               }
+                               while (c->busaddr != a) {
+                                       c = c->next;
+                                       if (c == h->cmpQ)
+                                               break;
+                               }

                        }
                        /*
                         * If we've found the command, take it off the
                         * completion Q and free it
                         */
                        }
                        /*
                         * If we've found the command, take it off the
                         * completion Q and free it
                         */

-                        if (c->busaddr == a) {
+                       if (c->busaddr == a) {

                                removeQ(&h->cmpQ, c);
                                if (c->cmd_type == CMD_RWREQ) {
                                        complete_command(h, c, 0);
                                removeQ(&h->cmpQ, c);
                                if (c->cmd_type == CMD_RWREQ) {
                                        complete_command(h, c, 0);


@@ -2561,130 +2682,79 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
                }
        }
 
                }
        }
 

-       /* check to see if we have maxed out the number of commands that can
-        * be placed on the queue.  If so then exit.  We do this check here
-        * in case the interrupt we serviced was from an ioctl and did not
-        * free any new commands.
-        */
-       if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
-               goto cleanup;
-
-       /* We have room on the queue for more commands.  Now we need to queue
-        * them up.  We will also keep track of the next queue to run so
-        * that every queue gets a chance to be started first.
-       */
-       for (j=0; j < h->highest_lun + 1; j++){
-               int curr_queue = (start_queue + j) % (h->highest_lun + 1);
-               /* make sure the disk has been added and the drive is real
-                * because this can be called from the middle of init_one.
-               */
-               if(!(h->drv[curr_queue].queue) ||
-                                  !(h->drv[curr_queue].heads))
-                       continue;
-               blk_start_queue(h->gendisk[curr_queue]->queue);
-
-               /* check to see if we have maxed out the number of commands
-                * that can be placed on the queue.
-               */
-               if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
-               {
-                       if (curr_queue == start_queue){
-                               h->next_to_run = (start_queue + 1) % (h->highest_lun + 1);
-                               goto cleanup;
-                       } else {
-                               h->next_to_run = curr_queue;
-                               goto cleanup;
-       }
-               } else {
-                       curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
-               }
-       }
-
-cleanup:

        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
        return IRQ_HANDLED;
 }
        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
        return IRQ_HANDLED;
 }

-/* 
- *  We cannot read the structure directly, for portablity we must use 
+
+/*
+ *  We cannot read the structure directly, for portability we must use

  *   the io functions.
  *   the io functions.

- *   This is for debug only. 
+ *   This is for debug only.

  */
 #ifdef CCISS_DEBUG
  */
 #ifdef CCISS_DEBUG

-static void print_cfg_table( CfgTable_struct *tb)
+static void print_cfg_table(CfgTable_struct *tb)

 {
        int i;
        char temp_name[17];
 
        printk("Controller Configuration information\n");
        printk("------------------------------------\n");
 {
        int i;
        char temp_name[17];
 
        printk("Controller Configuration information\n");
        printk("------------------------------------\n");

-       for(i=0;i<4;i++)
+       for (i = 0; i < 4; i++)

                temp_name[i] = readb(&(tb->Signature[i]));
                temp_name[i] = readb(&(tb->Signature[i]));

-       temp_name[4]='\0';
-       printk("   Signature = %s\n", temp_name); 
+       temp_name[4] = '\0';
+       printk("   Signature = %s\n", temp_name);

        printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));
        printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));

-       printk("   Transport methods supported = 0x%x\n", 
-                               readl(&(tb-> TransportSupport)));
-       printk("   Transport methods active = 0x%x\n", 
-                               readl(&(tb->TransportActive)));
-       printk("   Requested transport Method = 0x%x\n", 
-                       readl(&(tb->HostWrite.TransportRequest)));
-       printk("   Coalese Interrupt Delay = 0x%x\n", 
-                       readl(&(tb->HostWrite.CoalIntDelay)));
-       printk("   Coalese Interrupt Count = 0x%x\n", 
-                       readl(&(tb->HostWrite.CoalIntCount)));
-       printk("   Max outstanding commands = 0x%d\n", 
-                       readl(&(tb->CmdsOutMax)));
-       printk("   Bus Types = 0x%x\n", readl(&(tb-> BusTypes)));
-       for(i=0;i<16;i++)
+       printk("   Transport methods supported = 0x%x\n",
+              readl(&(tb->TransportSupport)));
+       printk("   Transport methods active = 0x%x\n",
+              readl(&(tb->TransportActive)));
+       printk("   Requested transport Method = 0x%x\n",
+              readl(&(tb->HostWrite.TransportRequest)));
+       printk("   Coalesce Interrupt Delay = 0x%x\n",
+              readl(&(tb->HostWrite.CoalIntDelay)));
+       printk("   Coalesce Interrupt Count = 0x%x\n",
+              readl(&(tb->HostWrite.CoalIntCount)));
+       printk("   Max outstanding commands = 0x%d\n",
+              readl(&(tb->CmdsOutMax)));
+       printk("   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
+       for (i = 0; i < 16; i++)

                temp_name[i] = readb(&(tb->ServerName[i]));
        temp_name[16] = '\0';
        printk("   Server Name = %s\n", temp_name);
                temp_name[i] = readb(&(tb->ServerName[i]));
        temp_name[16] = '\0';
        printk("   Server Name = %s\n", temp_name);

-       printk("   Heartbeat Counter = 0x%x\n\n\n", 
-                       readl(&(tb->HeartBeat)));
-}
-#endif /* CCISS_DEBUG */ 
-
-static void release_io_mem(ctlr_info_t *c)
-{
-       /* if IO mem was not protected do nothing */
-       if( c->io_mem_addr == 0)
-               return;
-       release_region(c->io_mem_addr, c->io_mem_length);
-       c->io_mem_addr = 0;
-       c->io_mem_length = 0;
+       printk("   Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));

 }
 }

+#endif                         /* CCISS_DEBUG */

 
 

-static int find_PCI_BAR_index(struct pci_dev *pdev,
-                               unsigned long pci_bar_addr)
+static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)

 {
        int i, offset, mem_type, bar_type;
 {
        int i, offset, mem_type, bar_type;

-       if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
+       if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */

                return 0;
        offset = 0;
                return 0;
        offset = 0;

-       for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
-               bar_type = pci_resource_flags(pdev, i) &
-                       PCI_BASE_ADDRESS_SPACE;
+       for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+               bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;

                if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
                        offset += 4;
                else {
                        mem_type = pci_resource_flags(pdev, i) &
                if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
                        offset += 4;
                else {
                        mem_type = pci_resource_flags(pdev, i) &

-                               PCI_BASE_ADDRESS_MEM_TYPE_MASK;
+                           PCI_BASE_ADDRESS_MEM_TYPE_MASK;

                        switch (mem_type) {
                        switch (mem_type) {

-                               case PCI_BASE_ADDRESS_MEM_TYPE_32:
-                               case PCI_BASE_ADDRESS_MEM_TYPE_1M:
-                                       offset += 4; /* 32 bit */
-                                       break;
-                               case PCI_BASE_ADDRESS_MEM_TYPE_64:
-                                       offset += 8;
-                                       break;
-                               default: /* reserved in PCI 2.2 */
-                                       printk(KERN_WARNING "Base address is invalid\n");
-                                       return -1;
+                       case PCI_BASE_ADDRESS_MEM_TYPE_32:
+                       case PCI_BASE_ADDRESS_MEM_TYPE_1M:
+                               offset += 4;    /* 32 bit */
+                               break;
+                       case PCI_BASE_ADDRESS_MEM_TYPE_64:
+                               offset += 8;
+                               break;
+                       default:        /* reserved in PCI 2.2 */
+                               printk(KERN_WARNING
+                                      "Base address is invalid\n");
+                               return -1;

                                break;
                        }
                }
                                break;
                        }
                }

-               if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
-                       return i+1;
+               if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
+                       return i + 1;

        }
        return -1;
 }
        }
        return -1;
 }


@@ -2693,53 +2763,52 @@ static int find_PCI_BAR_index(struct pci_dev *pdev,
  * controllers that are capable. If not, we use IO-APIC mode.
  */
 
  * controllers that are capable. If not, we use IO-APIC mode.
  */
 

-static void __devinit cciss_interrupt_mode(ctlr_info_t *c, struct pci_dev *pdev, __u32 board_id)
+static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
+                                          struct pci_dev *pdev, __u32 board_id)

 {
 #ifdef CONFIG_PCI_MSI
 {
 #ifdef CONFIG_PCI_MSI

-        int err;
-        struct msix_entry cciss_msix_entries[4] = {{0,0}, {0,1},
-                                                  {0,2}, {0,3}};
+       int err;
+       struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
+       {0, 2}, {0, 3}
+       };

 
        /* Some boards advertise MSI but don't really support it */
        if ((board_id == 0x40700E11) ||
 
        /* Some boards advertise MSI but don't really support it */
        if ((board_id == 0x40700E11) ||

-               (board_id == 0x40800E11) ||
-               (board_id == 0x40820E11) ||
-               (board_id == 0x40830E11))
+           (board_id == 0x40800E11) ||
+           (board_id == 0x40820E11) || (board_id == 0x40830E11))

                goto default_int_mode;
 
                goto default_int_mode;
 

-        if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
-                err = pci_enable_msix(pdev, cciss_msix_entries, 4);
-                if (!err) {
-                        c->intr[0] = cciss_msix_entries[0].vector;
-                        c->intr[1] = cciss_msix_entries[1].vector;
-                        c->intr[2] = cciss_msix_entries[2].vector;
-                        c->intr[3] = cciss_msix_entries[3].vector;
-                        c->msix_vector = 1;
-                        return;
-                }
-                if (err > 0) {
-                        printk(KERN_WARNING "cciss: only %d MSI-X vectors "
-                                        "available\n", err);
-                } else {
-                        printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
-                                               err);
-                }
-        }
-        if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
-                if (!pci_enable_msi(pdev)) {
-                        c->intr[SIMPLE_MODE_INT] = pdev->irq;
-                        c->msi_vector = 1;
-                        return;
-                } else {
-                        printk(KERN_WARNING "cciss: MSI init failed\n");
-                       c->intr[SIMPLE_MODE_INT] = pdev->irq;
-                        return;
-                }
-        }
-#endif /* CONFIG_PCI_MSI */
-       /* if we get here we're going to use the default interrupt mode */
+       if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
+               err = pci_enable_msix(pdev, cciss_msix_entries, 4);
+               if (!err) {
+                       c->intr[0] = cciss_msix_entries[0].vector;
+                       c->intr[1] = cciss_msix_entries[1].vector;
+                       c->intr[2] = cciss_msix_entries[2].vector;
+                       c->intr[3] = cciss_msix_entries[3].vector;
+                       c->msix_vector = 1;
+                       return;
+               }
+               if (err > 0) {
+                       printk(KERN_WARNING "cciss: only %d MSI-X vectors "
+                              "available\n", err);
+                       goto default_int_mode;
+               } else {
+                       printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
+                              err);
+                       goto default_int_mode;
+               }
+       }
+       if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
+               if (!pci_enable_msi(pdev)) {
+                       c->msi_vector = 1;
+               } else {
+                       printk(KERN_WARNING "cciss: MSI init failed\n");
+               }
+       }

 default_int_mode:
 default_int_mode:

-        c->intr[SIMPLE_MODE_INT] = pdev->irq;
+#endif                         /* CONFIG_PCI_MSI */
+       /* if we get here we're going to use the default interrupt mode */
+       c->intr[SIMPLE_MODE_INT] = pdev->irq;

        return;
 }
 
        return;
 }
 


@@ -2750,58 +2819,40 @@ static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
        __u64 cfg_offset;
        __u32 cfg_base_addr;
        __u64 cfg_base_addr_index;
        __u64 cfg_offset;
        __u32 cfg_base_addr;
        __u64 cfg_base_addr_index;

-       int i;
+       int i, err;

 
        /* check to see if controller has been disabled */
        /* BEFORE trying to enable it */
 
        /* check to see if controller has been disabled */
        /* BEFORE trying to enable it */

-       (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
-       if(!(command & 0x02))
-       {
-               printk(KERN_WARNING "cciss: controller appears to be disabled\n");
-               return(-1);
+       (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
+       if (!(command & 0x02)) {
+               printk(KERN_WARNING
+                      "cciss: controller appears to be disabled\n");
+               return -ENODEV;

        }
 
        }
 

-       if (pci_enable_device(pdev))
-       {
+       err = pci_enable_device(pdev);
+       if (err) {

                printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
                printk(KERN_ERR "cciss: Unable to Enable PCI device\n");

-               return( -1);
+               return err;
+       }
+
+       err = pci_request_regions(pdev, "cciss");
+       if (err) {
+               printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
+                      "aborting\n");
+               return err;

        }
 
        subsystem_vendor_id = pdev->subsystem_vendor;
        subsystem_device_id = pdev->subsystem_device;
        board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
        }
 
        subsystem_vendor_id = pdev->subsystem_vendor;
        subsystem_device_id = pdev->subsystem_device;
        board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |

-                                       subsystem_vendor_id);
-
-       /* search for our IO range so we can protect it */
-       for(i=0; i<DEVICE_COUNT_RESOURCE; i++)
-       {
-               /* is this an IO range */ 
-               if( pci_resource_flags(pdev, i) & 0x01 ) {
-                       c->io_mem_addr = pci_resource_start(pdev, i);
-                       c->io_mem_length = pci_resource_end(pdev, i) -
-                               pci_resource_start(pdev, i) +1;
-#ifdef CCISS_DEBUG
-                       printk("IO value found base_addr[%d] %lx %lx\n", i,
-                               c->io_mem_addr, c->io_mem_length);
-#endif /* CCISS_DEBUG */
-                       /* register the IO range */ 
-                       if(!request_region( c->io_mem_addr,
-                                        c->io_mem_length, "cciss"))
-                       {
-                               printk(KERN_WARNING "cciss I/O memory range already in use addr=%lx length=%ld\n",
-                               c->io_mem_addr, c->io_mem_length);
-                               c->io_mem_addr= 0;
-                               c->io_mem_length = 0;
-                       } 
-                       break;
-               }
-       }
+                   subsystem_vendor_id);

 
 #ifdef CCISS_DEBUG
        printk("command = %x\n", command);
        printk("irq = %x\n", pdev->irq);
        printk("board_id = %x\n", board_id);
 
 #ifdef CCISS_DEBUG
        printk("command = %x\n", command);
        printk("irq = %x\n", pdev->irq);
        printk("board_id = %x\n", board_id);

-#endif /* CCISS_DEBUG */ 
+#endif                         /* CCISS_DEBUG */

 
 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
  * else we use the IO-APIC interrupt assigned to us by system ROM.
 
 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
  * else we use the IO-APIC interrupt assigned to us by system ROM.


@@ -2810,27 +2861,28 @@ static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
 
        /*
         * Memory base addr is first addr , the second points to the config
 
        /*
         * Memory base addr is first addr , the second points to the config

-         *   table
+        *   table

         */
 
         */
 

-       c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
+       c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */

 #ifdef CCISS_DEBUG
        printk("address 0 = %x\n", c->paddr);
 #ifdef CCISS_DEBUG
        printk("address 0 = %x\n", c->paddr);

-#endif /* CCISS_DEBUG */ 
-       c->vaddr = remap_pci_mem(c->paddr, 200);
+#endif                         /* CCISS_DEBUG */
+       c->vaddr = remap_pci_mem(c->paddr, 0x250);

 
        /* Wait for the board to become ready.  (PCI hotplug needs this.)
         * We poll for up to 120 secs, once per 100ms. */
 
        /* Wait for the board to become ready.  (PCI hotplug needs this.)
         * We poll for up to 120 secs, once per 100ms. */

-       for (i=0; i < 1200; i++) {
+       for (i = 0; i < 1200; i++) {

                scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
                if (scratchpad == CCISS_FIRMWARE_READY)
                        break;
                set_current_state(TASK_INTERRUPTIBLE);
                scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
                if (scratchpad == CCISS_FIRMWARE_READY)
                        break;
                set_current_state(TASK_INTERRUPTIBLE);

-               schedule_timeout(HZ / 10); /* wait 100ms */
+               schedule_timeout(HZ / 10);      /* wait 100ms */

        }
        if (scratchpad != CCISS_FIRMWARE_READY) {
                printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");
        }
        if (scratchpad != CCISS_FIRMWARE_READY) {
                printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");

-               return -1;
+               err = -ENODEV;
+               goto err_out_free_res;

        }
 
        /* get the address index number */
        }
 
        /* get the address index number */


@@ -2838,253 +2890,283 @@ static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
        cfg_base_addr &= (__u32) 0x0000ffff;
 #ifdef CCISS_DEBUG
        printk("cfg base address = %x\n", cfg_base_addr);
        cfg_base_addr &= (__u32) 0x0000ffff;
 #ifdef CCISS_DEBUG
        printk("cfg base address = %x\n", cfg_base_addr);

-#endif /* CCISS_DEBUG */
-       cfg_base_addr_index =
-               find_PCI_BAR_index(pdev, cfg_base_addr);
+#endif                         /* CCISS_DEBUG */
+       cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);

 #ifdef CCISS_DEBUG
        printk("cfg base address index = %x\n", cfg_base_addr_index);
 #ifdef CCISS_DEBUG
        printk("cfg base address index = %x\n", cfg_base_addr_index);

-#endif /* CCISS_DEBUG */
+#endif                         /* CCISS_DEBUG */

        if (cfg_base_addr_index == -1) {
                printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
        if (cfg_base_addr_index == -1) {
                printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");

-               release_io_mem(c);
-               return -1;
+               err = -ENODEV;
+               goto err_out_free_res;

        }
 
        cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
 #ifdef CCISS_DEBUG
        printk("cfg offset = %x\n", cfg_offset);
        }
 
        cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
 #ifdef CCISS_DEBUG
        printk("cfg offset = %x\n", cfg_offset);

-#endif /* CCISS_DEBUG */
-       c->cfgtable =  remap_pci_mem(pci_resource_start(pdev,
-                               cfg_base_addr_index) + cfg_offset,
-                               sizeof(CfgTable_struct));
+#endif                         /* CCISS_DEBUG */
+       c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
+                                                      cfg_base_addr_index) +
+                                   cfg_offset, sizeof(CfgTable_struct));

        c->board_id = board_id;
 
 #ifdef CCISS_DEBUG
        print_cfg_table(c->cfgtable);
        c->board_id = board_id;
 
 #ifdef CCISS_DEBUG
        print_cfg_table(c->cfgtable);

-#endif /* CCISS_DEBUG */
+#endif                         /* CCISS_DEBUG */

 
 

-       for(i=0; i<NR_PRODUCTS; i++) {
+       for (i = 0; i < ARRAY_SIZE(products); i++) {

                if (board_id == products[i].board_id) {
                        c->product_name = products[i].product_name;
                        c->access = *(products[i].access);
                if (board_id == products[i].board_id) {
                        c->product_name = products[i].product_name;
                        c->access = *(products[i].access);

+                       c->nr_cmds = products[i].nr_cmds;

                        break;
                }
        }
                        break;
                }
        }

-       if (i == NR_PRODUCTS) {
-               printk(KERN_WARNING "cciss: Sorry, I don't know how"
-                       " to access the Smart Array controller %08lx\n", 
-                               (unsigned long)board_id);
-               return -1;
-       }
-       if (  (readb(&c->cfgtable->Signature[0]) != 'C') ||
-             (readb(&c->cfgtable->Signature[1]) != 'I') ||
-             (readb(&c->cfgtable->Signature[2]) != 'S') ||
-             (readb(&c->cfgtable->Signature[3]) != 'S') )
-       {
+       if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
+           (readb(&c->cfgtable->Signature[1]) != 'I') ||
+           (readb(&c->cfgtable->Signature[2]) != 'S') ||
+           (readb(&c->cfgtable->Signature[3]) != 'S')) {

                printk("Does not appear to be a valid CISS config table\n");
                printk("Does not appear to be a valid CISS config table\n");

-               return -1;
+               err = -ENODEV;
+               goto err_out_free_res;
+       }
+       /* We didn't find the controller in our list. We know the
+        * signature is valid. If it's an HP device let's try to
+        * bind to the device and fire it up. Otherwise we bail.
+        */
+       if (i == ARRAY_SIZE(products)) {
+               if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
+                       c->product_name = products[i-1].product_name;
+                       c->access = *(products[i-1].access);
+                       c->nr_cmds = products[i-1].nr_cmds;
+                       printk(KERN_WARNING "cciss: This is an unknown "
+                               "Smart Array controller.\n"
+                               "cciss: Please update to the latest driver "
+                               "available from www.hp.com.\n");
+               } else {
+                       printk(KERN_WARNING "cciss: Sorry, I don't know how"
+                               " to access the Smart Array controller %08lx\n"
+                                       , (unsigned long)board_id);
+                       err = -ENODEV;
+                       goto err_out_free_res;
+               }

        }
        }

-

 #ifdef CONFIG_X86
 #ifdef CONFIG_X86

-{
-       /* Need to enable prefetch in the SCSI core for 6400 in x86 */
-       __u32 prefetch;
-       prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
-       prefetch |= 0x100;
-       writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
-}
+       {
+               /* Need to enable prefetch in the SCSI core for 6400 in x86 */
+               __u32 prefetch;
+               prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
+               prefetch |= 0x100;
+               writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
+       }

 #endif
 
 #endif
 

+       /* Disabling DMA prefetch for the P600
+        * An ASIC bug may result in a prefetch beyond
+        * physical memory.
+        */
+       if(board_id == 0x3225103C) {
+               __u32 dma_prefetch;
+               dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
+               dma_prefetch |= 0x8000;
+               writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
+       }
+

 #ifdef CCISS_DEBUG
        printk("Trying to put board into Simple mode\n");
 #ifdef CCISS_DEBUG
        printk("Trying to put board into Simple mode\n");

-#endif /* CCISS_DEBUG */ 
+#endif                         /* CCISS_DEBUG */

        c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
        c->max_commands = readl(&(c->cfgtable->CmdsOutMax));

-       /* Update the field, and then ring the doorbell */ 
-       writel( CFGTBL_Trans_Simple, 
-               &(c->cfgtable->HostWrite.TransportRequest));
-       writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
+       /* Update the field, and then ring the doorbell */
+       writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
+       writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);

 
        /* under certain very rare conditions, this can take awhile.
         * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
         * as we enter this code.) */
 
        /* under certain very rare conditions, this can take awhile.
         * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
         * as we enter this code.) */

-       for(i=0;i<MAX_CONFIG_WAIT;i++) {
+       for (i = 0; i < MAX_CONFIG_WAIT; i++) {

                if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
                        break;
                /* delay and try again */
                set_current_state(TASK_INTERRUPTIBLE);
                schedule_timeout(10);
                if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
                        break;
                /* delay and try again */
                set_current_state(TASK_INTERRUPTIBLE);
                schedule_timeout(10);

-       }       
+       }

 
 #ifdef CCISS_DEBUG
 
 #ifdef CCISS_DEBUG

-       printk(KERN_DEBUG "I counter got to %d %x\n", i, readl(c->vaddr + SA5_DOORBELL));
-#endif /* CCISS_DEBUG */
+       printk(KERN_DEBUG "I counter got to %d %x\n", i,
+              readl(c->vaddr + SA5_DOORBELL));
+#endif                         /* CCISS_DEBUG */

 #ifdef CCISS_DEBUG
 #ifdef CCISS_DEBUG

-       print_cfg_table(c->cfgtable);   
-#endif /* CCISS_DEBUG */ 
+       print_cfg_table(c->cfgtable);
+#endif                         /* CCISS_DEBUG */

 
 

-       if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
-       {
+       if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {

                printk(KERN_WARNING "cciss: unable to get board into"
                printk(KERN_WARNING "cciss: unable to get board into"

-                                       " simple mode\n");
-               return -1;
+                      " simple mode\n");
+               err = -ENODEV;
+               goto err_out_free_res;

        }
        return 0;
 
        }
        return 0;
 

+err_out_free_res:
+       /*
+        * Deliberately omit pci_disable_device(): it does something nasty to
+        * Smart Array controllers that pci_enable_device does not undo
+        */
+       pci_release_regions(pdev);
+       return err;

 }
 
 }
 

-/* 
- * Gets information about the local volumes attached to the controller. 
- */ 
+/*
+ * Gets information about the local volumes attached to the controller.
+ */

 static void cciss_getgeometry(int cntl_num)
 {
        ReportLunData_struct *ld_buff;
 static void cciss_getgeometry(int cntl_num)
 {
        ReportLunData_struct *ld_buff;

-       ReadCapdata_struct *size_buff;

        InquiryData_struct *inq_buff;
        int return_code;
        int i;
        int listlength = 0;
        __u32 lunid = 0;
        int block_size;
        InquiryData_struct *inq_buff;
        int return_code;
        int i;
        int listlength = 0;
        __u32 lunid = 0;
        int block_size;

-       int total_size; 
+       sector_t total_size;

 
 

-       ld_buff = kmalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
-       if (ld_buff == NULL)
-       {
+       ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
+       if (ld_buff == NULL) {

                printk(KERN_ERR "cciss: out of memory\n");
                return;
        }
                printk(KERN_ERR "cciss: out of memory\n");
                return;
        }

-       memset(ld_buff, 0, sizeof(ReportLunData_struct));
-       size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
-        if (size_buff == NULL)
-        {
-                printk(KERN_ERR "cciss: out of memory\n");
+       inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
+       if (inq_buff == NULL) {
+               printk(KERN_ERR "cciss: out of memory\n");

                kfree(ld_buff);
                kfree(ld_buff);

-                return;
-        }
-       inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
-        if (inq_buff == NULL)
-        {
-                printk(KERN_ERR "cciss: out of memory\n");
-                kfree(ld_buff);
-               kfree(size_buff);
-                return;
-        }
-       /* Get the firmware version */ 
-       return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff, 
-               sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD);
-       if (return_code == IO_OK)
-       {
+               return;
+       }
+       /* Get the firmware version */
+       return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
+                             sizeof(InquiryData_struct), 0, 0, 0, NULL,
+                             TYPE_CMD);
+       if (return_code == IO_OK) {

                hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
                hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
                hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
                hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
                hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
                hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
                hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
                hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];

-       } else /* send command failed */
-       {
+       } else {                /* send command failed */
+

                printk(KERN_WARNING "cciss: unable to determine firmware"
                printk(KERN_WARNING "cciss: unable to determine firmware"

-                       " version of controller\n");
+                      " version of controller\n");

        }
        }

-       /* Get the number of logical volumes */ 
-       return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff, 
-                       sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD);
+       /* Get the number of logical volumes */
+       return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
+                             sizeof(ReportLunData_struct), 0, 0, 0, NULL,
+                             TYPE_CMD);

 
 

-       if( return_code == IO_OK)
-       {
+       if (return_code == IO_OK) {

 #ifdef CCISS_DEBUG
                printk("LUN Data\n--------------------------\n");
 #ifdef CCISS_DEBUG
                printk("LUN Data\n--------------------------\n");

-#endif /* CCISS_DEBUG */ 
-
-               listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
-               listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
-               listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;  
+#endif                         /* CCISS_DEBUG */
+
+               listlength |=
+                   (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
+               listlength |=
+                   (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
+               listlength |=
+                   (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;

                listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
                listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);

-       } else /* reading number of logical volumes failed */
-       {
+       } else {                /* reading number of logical volumes failed */
+

                printk(KERN_WARNING "cciss: report logical volume"
                printk(KERN_WARNING "cciss: report logical volume"

-                       " command failed\n");
+                      " command failed\n");

                listlength = 0;
        }
                listlength = 0;
        }

-       hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
-       if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
-       {
-               printk(KERN_ERR "ciss:  only %d number of logical volumes supported\n",
-                       CISS_MAX_LUN);
+       hba[cntl_num]->num_luns = listlength / 8;       // 8 bytes pre entry
+       if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
+               printk(KERN_ERR
+                      "ciss:  only %d number of logical volumes supported\n",
+                      CISS_MAX_LUN);

                hba[cntl_num]->num_luns = CISS_MAX_LUN;
        }
 #ifdef CCISS_DEBUG
                hba[cntl_num]->num_luns = CISS_MAX_LUN;
        }
 #ifdef CCISS_DEBUG

-       printk(KERN_DEBUG "Length = %x %x %x %x = %d\n", ld_buff->LUNListLength[0],
-               ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
-               ld_buff->LUNListLength[3],  hba[cntl_num]->num_luns);
-#endif /* CCISS_DEBUG */
-
-       hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns-1;
-//     for(i=0; i<  hba[cntl_num]->num_luns; i++)
-       for(i=0; i < CISS_MAX_LUN; i++)
-       {
-               if (i < hba[cntl_num]->num_luns){
-                       lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
-                                << 24;
-                       lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
-                                << 16;
-                       lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
-                                << 8;
-               lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
-               
-               hba[cntl_num]->drv[i].LunID = lunid;
-
+       printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
+              ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
+              ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
+              hba[cntl_num]->num_luns);
+#endif                         /* CCISS_DEBUG */
+
+       hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
+       for (i = 0; i < CISS_MAX_LUN; i++) {
+               if (i < hba[cntl_num]->num_luns) {
+                       lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
+                           << 24;
+                       lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
+                           << 16;
+                       lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
+                           << 8;
+                       lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
+
+                       hba[cntl_num]->drv[i].LunID = lunid;

 
 #ifdef CCISS_DEBUG
 
 #ifdef CCISS_DEBUG

-               printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i, 
-                       ld_buff->LUN[i][0], ld_buff->LUN[i][1],
-                       ld_buff->LUN[i][2], ld_buff->LUN[i][3],
-                       hba[cntl_num]->drv[i].LunID);
-#endif /* CCISS_DEBUG */
-               cciss_read_capacity(cntl_num, i, size_buff, 0,
+                       printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i,
+                              ld_buff->LUN[i][0], ld_buff->LUN[i][1],
+                              ld_buff->LUN[i][2], ld_buff->LUN[i][3],
+                              hba[cntl_num]->drv[i].LunID);
+#endif                         /* CCISS_DEBUG */
+
+               /* testing to see if 16-byte CDBs are already being used */
+               if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
+                       cciss_read_capacity_16(cntl_num, i, 0,
+                                           &total_size, &block_size);
+                       goto geo_inq;
+               }
+               cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
+
+               /* total_size = last LBA + 1 */
+               if(total_size == (__u32) 0) {
+                       cciss_read_capacity_16(cntl_num, i, 0,

                        &total_size, &block_size);
                        &total_size, &block_size);

+                       hba[cntl_num]->cciss_read = CCISS_READ_16;
+                       hba[cntl_num]->cciss_write = CCISS_WRITE_16;
+               } else {
+                       hba[cntl_num]->cciss_read = CCISS_READ_10;
+                       hba[cntl_num]->cciss_write = CCISS_WRITE_10;
+               }
+geo_inq:

                        cciss_geometry_inquiry(cntl_num, i, 0, total_size,
                        cciss_geometry_inquiry(cntl_num, i, 0, total_size,

-                               block_size, inq_buff, &hba[cntl_num]->drv[i]);
+                                              block_size, inq_buff,
+                                              &hba[cntl_num]->drv[i]);

                } else {
                        /* initialize raid_level to indicate a free space */
                        hba[cntl_num]->drv[i].raid_level = -1;
                }
        }
        kfree(ld_buff);
                } else {
                        /* initialize raid_level to indicate a free space */
                        hba[cntl_num]->drv[i].raid_level = -1;
                }
        }
        kfree(ld_buff);

-       kfree(size_buff);

        kfree(inq_buff);
        kfree(inq_buff);

-}      
+}

 
 /* Function to find the first free pointer into our hba[] array */
 /* Returns -1 if no free entries are left.  */
 static int alloc_cciss_hba(void)
 {
 
 /* Function to find the first free pointer into our hba[] array */
 /* Returns -1 if no free entries are left.  */
 static int alloc_cciss_hba(void)
 {

-       struct gendisk *disk[NWD];
-       int i, n;
-       for (n = 0; n < NWD; n++) {
-               disk[n] = alloc_disk(1 << NWD_SHIFT);
-               if (!disk[n])
-                       goto out;
-       }
+       int i;

 
 

-       for(i=0; i< MAX_CTLR; i++) {
+       for (i = 0; i < MAX_CTLR; i++) {

                if (!hba[i]) {
                        ctlr_info_t *p;
                if (!hba[i]) {
                        ctlr_info_t *p;

-                       p = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
+                       p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);

                        if (!p)
                                goto Enomem;
                        if (!p)
                                goto Enomem;

-                       memset(p, 0, sizeof(ctlr_info_t));
-                       for (n = 0; n < NWD; n++)
-                               p->gendisk[n] = disk[n];
+                       p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
+                       if (!p->gendisk[0])
+                               goto Enomem;

                        hba[i] = p;
                        return i;
                }
        }
        printk(KERN_WARNING "cciss: This driver supports a maximum"
                        hba[i] = p;
                        return i;
                }
        }
        printk(KERN_WARNING "cciss: This driver supports a maximum"

-               " of %d controllers.\n", MAX_CTLR);
-       goto out;
+              " of %d controllers.\n", MAX_CTLR);
+       return -1;

 Enomem:
        printk(KERN_ERR "cciss: out of memory.\n");
 Enomem:
        printk(KERN_ERR "cciss: out of memory.\n");

-out:
-       while (n--)
-               put_disk(disk[n]);

        return -1;
 }
 
        return -1;
 }
 


@@ -3094,7 +3176,7 @@ static void free_hba(int i)
        int n;
 
        hba[i] = NULL;
        int n;
 
        hba[i] = NULL;

-       for (n = 0; n < NWD; n++)
+       for (n = 0; n < CISS_MAX_LUN; n++)

                put_disk(p->gendisk[n]);
        kfree(p);
 }
                put_disk(p->gendisk[n]);
        kfree(p);
 }


@@ -3105,20 +3187,16 @@ static void free_hba(int i)
  *  returns the number of block devices registered.
  */
 static int __devinit cciss_init_one(struct pci_dev *pdev,
  *  returns the number of block devices registered.
  */
 static int __devinit cciss_init_one(struct pci_dev *pdev,

-       const struct pci_device_id *ent)
+                                   const struct pci_device_id *ent)

 {
 {

-       request_queue_t *q;

        int i;
        int i;

-       int j;
+       int j = 0;

        int rc;
        int rc;

+       int dac;

 
 

-       printk(KERN_DEBUG "cciss: Device 0x%x has been found at"
-                       " bus %d dev %d func %d\n",
-               pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
-                       PCI_FUNC(pdev->devfn));

        i = alloc_cciss_hba();
        i = alloc_cciss_hba();

-       if(i < 0)
-               return (-1);
+       if (i < 0)
+               return -1;

 
        hba[i]->busy_initializing = 1;
 
 
        hba[i]->busy_initializing = 1;
 


@@ -3131,11 +3209,11 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
 
        /* configure PCI DMA stuff */
        if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
 
        /* configure PCI DMA stuff */
        if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))

-               printk("cciss: using DAC cycles\n");
+               dac = 1;

        else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
        else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))

-               printk("cciss: not using DAC cycles\n");
+               dac = 0;

        else {
        else {

-               printk("cciss: no suitable DMA available\n");
+               printk(KERN_ERR "cciss: no suitable DMA available\n");

                goto clean1;
        }
 
                goto clean1;
        }
 


@@ -3147,60 +3225,69 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
        if (i < MAX_CTLR_ORIG)
                hba[i]->major = COMPAQ_CISS_MAJOR + i;
        rc = register_blkdev(hba[i]->major, hba[i]->devname);
        if (i < MAX_CTLR_ORIG)
                hba[i]->major = COMPAQ_CISS_MAJOR + i;
        rc = register_blkdev(hba[i]->major, hba[i]->devname);

-       if(rc == -EBUSY || rc == -EINVAL) {
+       if (rc == -EBUSY || rc == -EINVAL) {

                printk(KERN_ERR
                printk(KERN_ERR

-                       "cciss:  Unable to get major number %d for %s "
-                       "on hba %d\n", hba[i]->major, hba[i]->devname, i);
+                      "cciss:  Unable to get major number %d for %s "
+                      "on hba %d\n", hba[i]->major, hba[i]->devname, i);

                goto clean1;
                goto clean1;

-       }
-       else {
+       } else {

                if (i >= MAX_CTLR_ORIG)
                        hba[i]->major = rc;
        }
 
        /* make sure the board interrupts are off */
        hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
                if (i >= MAX_CTLR_ORIG)
                        hba[i]->major = rc;
        }
 
        /* make sure the board interrupts are off */
        hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);

-       if( request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
-               SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
-                       hba[i]->devname, hba[i])) {
+       if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
+                       IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {

                printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
                printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",

-                       hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
+                      hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);

                goto clean2;
        }
                goto clean2;
        }

-       hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
-       hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
-               hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct), 
-               &(hba[i]->cmd_pool_dhandle));
-       hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
-               hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct), 
-               &(hba[i]->errinfo_pool_dhandle));
-       if((hba[i]->cmd_pool_bits == NULL) 
-               || (hba[i]->cmd_pool == NULL)
-               || (hba[i]->errinfo_pool == NULL)) {
-                printk( KERN_ERR "cciss: out of memory");
+
+       printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
+              hba[i]->devname, pdev->device, pci_name(pdev),
+              hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
+
+       hba[i]->cmd_pool_bits =
+           kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
+                     1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
+       hba[i]->cmd_pool = (CommandList_struct *)
+           pci_alloc_consistent(hba[i]->pdev,
+                   hba[i]->nr_cmds * sizeof(CommandList_struct),
+                   &(hba[i]->cmd_pool_dhandle));
+       hba[i]->errinfo_pool = (ErrorInfo_struct *)
+           pci_alloc_consistent(hba[i]->pdev,
+                   hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
+                   &(hba[i]->errinfo_pool_dhandle));
+       if ((hba[i]->cmd_pool_bits == NULL)
+           || (hba[i]->cmd_pool == NULL)
+           || (hba[i]->errinfo_pool == NULL)) {
+               printk(KERN_ERR "cciss: out of memory");

                goto clean4;
        }
 #ifdef CONFIG_CISS_SCSI_TAPE
                goto clean4;
        }
 #ifdef CONFIG_CISS_SCSI_TAPE

-       hba[i]->scsi_rejects.complete = 
-               kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) * 
-                       (NR_CMDS + 5), GFP_KERNEL);
+       hba[i]->scsi_rejects.complete =
+           kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
+                   (hba[i]->nr_cmds + 5), GFP_KERNEL);

        if (hba[i]->scsi_rejects.complete == NULL) {
        if (hba[i]->scsi_rejects.complete == NULL) {

-                printk( KERN_ERR "cciss: out of memory");
+               printk(KERN_ERR "cciss: out of memory");

                goto clean4;
        }
 #endif
        spin_lock_init(&hba[i]->lock);
 
                goto clean4;
        }
 #endif
        spin_lock_init(&hba[i]->lock);
 

-       /* Initialize the pdev driver private data. 
-               have it point to hba[i].  */
+       /* Initialize the pdev driver private data.
+          have it point to hba[i].  */

        pci_set_drvdata(pdev, hba[i]);
        pci_set_drvdata(pdev, hba[i]);

-       /* command and error info recs zeroed out before 
-                       they are used */
-        memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
+       /* command and error info recs zeroed out before
+          they are used */
+       memset(hba[i]->cmd_pool_bits, 0,
+              ((hba[i]->nr_cmds + BITS_PER_LONG -
+                1) / BITS_PER_LONG) * sizeof(unsigned long));

 
 

-#ifdef CCISS_DEBUG     
-       printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n",i);
-#endif /* CCISS_DEBUG */
+#ifdef CCISS_DEBUG
+       printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
+#endif                         /* CCISS_DEBUG */

 
        cciss_getgeometry(i);
 
 
        cciss_getgeometry(i);
 


@@ -3210,18 +3297,34 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
        hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
 
        cciss_procinit(i);
        hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
 
        cciss_procinit(i);

+
+       hba[i]->cciss_max_sectors = 2048;
+

        hba[i]->busy_initializing = 0;
 
        hba[i]->busy_initializing = 0;
 

-       for(j=0; j < NWD; j++) { /* mfm */
+       do {

                drive_info_struct *drv = &(hba[i]->drv[j]);
                struct gendisk *disk = hba[i]->gendisk[j];
                drive_info_struct *drv = &(hba[i]->drv[j]);
                struct gendisk *disk = hba[i]->gendisk[j];

+               request_queue_t *q;
+
+               /* Check if the disk was allocated already */
+               if (!disk){
+                       hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
+                       disk = hba[i]->gendisk[j];
+               }
+
+               /* Check that the disk was able to be allocated */
+               if (!disk) {
+                       printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
+                       goto clean4;
+               }

 
                q = blk_init_queue(do_cciss_request, &hba[i]->lock);
                if (!q) {
                        printk(KERN_ERR
 
                q = blk_init_queue(do_cciss_request, &hba[i]->lock);
                if (!q) {
                        printk(KERN_ERR

-                          "cciss:  unable to allocate queue for disk %d\n",
-                          j);
-                       break;
+                              "cciss:  unable to allocate queue for disk %d\n",
+                              j);
+                       goto clean4;

                }
                drv->queue = q;
 
                }
                drv->queue = q;
 


@@ -3234,135 +3337,147 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
                /* This is a limit in the driver and could be eliminated. */
                blk_queue_max_phys_segments(q, MAXSGENTRIES);
 
                /* This is a limit in the driver and could be eliminated. */
                blk_queue_max_phys_segments(q, MAXSGENTRIES);
 

-               blk_queue_max_sectors(q, 512);
+               blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);

 
                blk_queue_softirq_done(q, cciss_softirq_done);
 
                q->queuedata = hba[i];
                sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
 
                blk_queue_softirq_done(q, cciss_softirq_done);
 
                q->queuedata = hba[i];
                sprintf(disk->disk_name, "cciss/c%dd%d", i, j);

-               sprintf(disk->devfs_name, "cciss/host%d/target%d", i, j);

                disk->major = hba[i]->major;
                disk->first_minor = j << NWD_SHIFT;
                disk->fops = &cciss_fops;
                disk->queue = q;
                disk->private_data = drv;
                disk->major = hba[i]->major;
                disk->first_minor = j << NWD_SHIFT;
                disk->fops = &cciss_fops;
                disk->queue = q;
                disk->private_data = drv;

+               disk->driverfs_dev = &pdev->dev;

                /* we must register the controller even if no disks exist */
                /* this is for the online array utilities */
                /* we must register the controller even if no disks exist */
                /* this is for the online array utilities */

-               if(!drv->heads && j)
+               if (!drv->heads && j)

                        continue;
                blk_queue_hardsect_size(q, drv->block_size);
                set_capacity(disk, drv->nr_blocks);
                add_disk(disk);
                        continue;
                blk_queue_hardsect_size(q, drv->block_size);
                set_capacity(disk, drv->nr_blocks);
                add_disk(disk);

-       }
+               j++;
+       } while (j <= hba[i]->highest_lun);

 
 

-       return(1);
+       return 1;

 
 

-clean4:
+      clean4:

 #ifdef CONFIG_CISS_SCSI_TAPE
 #ifdef CONFIG_CISS_SCSI_TAPE

-       if(hba[i]->scsi_rejects.complete)
-               kfree(hba[i]->scsi_rejects.complete);
+       kfree(hba[i]->scsi_rejects.complete);

 #endif
        kfree(hba[i]->cmd_pool_bits);
 #endif
        kfree(hba[i]->cmd_pool_bits);

-       if(hba[i]->cmd_pool)
+       if (hba[i]->cmd_pool)

                pci_free_consistent(hba[i]->pdev,
                pci_free_consistent(hba[i]->pdev,

-                       NR_CMDS * sizeof(CommandList_struct),
-                       hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
-       if(hba[i]->errinfo_pool)
+                                   hba[i]->nr_cmds * sizeof(CommandList_struct),
+                                   hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
+       if (hba[i]->errinfo_pool)

                pci_free_consistent(hba[i]->pdev,
                pci_free_consistent(hba[i]->pdev,

-                       NR_CMDS * sizeof( ErrorInfo_struct),
-                       hba[i]->errinfo_pool,
-                       hba[i]->errinfo_pool_dhandle);
+                                   hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
+                                   hba[i]->errinfo_pool,
+                                   hba[i]->errinfo_pool_dhandle);

        free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
        free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);

-clean2:
+      clean2:

        unregister_blkdev(hba[i]->major, hba[i]->devname);
        unregister_blkdev(hba[i]->major, hba[i]->devname);

-clean1:
-       release_io_mem(hba[i]);
+      clean1:

        hba[i]->busy_initializing = 0;
        hba[i]->busy_initializing = 0;

+       /* cleanup any queues that may have been initialized */
+       for (j=0; j <= hba[i]->highest_lun; j++){
+               drive_info_struct *drv = &(hba[i]->drv[j]);
+               if (drv->queue)
+                       blk_cleanup_queue(drv->queue);
+       }
+       /*
+        * Deliberately omit pci_disable_device(): it does something nasty to
+        * Smart Array controllers that pci_enable_device does not undo
+        */
+       pci_release_regions(pdev);
+       pci_set_drvdata(pdev, NULL);

        free_hba(i);
        free_hba(i);

-       return(-1);
+       return -1;

 }
 
 }
 

-static void __devexit cciss_remove_one (struct pci_dev *pdev)
+static void __devexit cciss_remove_one(struct pci_dev *pdev)

 {
        ctlr_info_t *tmp_ptr;
        int i, j;
        char flush_buf[4];
 {
        ctlr_info_t *tmp_ptr;
        int i, j;
        char flush_buf[4];

-       int return_code; 
+       int return_code;

 
 

-       if (pci_get_drvdata(pdev) == NULL)
-       {
-               printk( KERN_ERR "cciss: Unable to remove device \n");
+       if (pci_get_drvdata(pdev) == NULL) {
+               printk(KERN_ERR "cciss: Unable to remove device \n");

                return;
        }
        tmp_ptr = pci_get_drvdata(pdev);
        i = tmp_ptr->ctlr;
                return;
        }
        tmp_ptr = pci_get_drvdata(pdev);
        i = tmp_ptr->ctlr;

-       if (hba[i] == NULL) 
-       {
+       if (hba[i] == NULL) {

                printk(KERN_ERR "cciss: device appears to "
                printk(KERN_ERR "cciss: device appears to "

-                       "already be removed \n");
+                      "already be removed \n");

                return;
        }
        /* Turn board interrupts off  and send the flush cache command */
        /* sendcmd will turn off interrupt, and send the flush...
                return;
        }
        /* Turn board interrupts off  and send the flush cache command */
        /* sendcmd will turn off interrupt, and send the flush...

-       * To write all data in the battery backed cache to disks */
+        * To write all data in the battery backed cache to disks */

        memset(flush_buf, 0, 4);
        return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
        memset(flush_buf, 0, 4);
        return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,

-                               TYPE_CMD);
-       if(return_code != IO_OK)
-       {
-               printk(KERN_WARNING "Error Flushing cache on controller %d\n", 
-                       i);
+                             TYPE_CMD);
+       if (return_code != IO_OK) {
+               printk(KERN_WARNING "Error Flushing cache on controller %d\n",
+                      i);

        }
        free_irq(hba[i]->intr[2], hba[i]);
 
 #ifdef CONFIG_PCI_MSI
        }
        free_irq(hba[i]->intr[2], hba[i]);
 
 #ifdef CONFIG_PCI_MSI

-        if (hba[i]->msix_vector)
-                pci_disable_msix(hba[i]->pdev);
-        else if (hba[i]->msi_vector)
-                pci_disable_msi(hba[i]->pdev);
-#endif /* CONFIG_PCI_MSI */
+       if (hba[i]->msix_vector)
+               pci_disable_msix(hba[i]->pdev);
+       else if (hba[i]->msi_vector)
+               pci_disable_msi(hba[i]->pdev);
+#endif                         /* CONFIG_PCI_MSI */

 
 

-       pci_set_drvdata(pdev, NULL);

        iounmap(hba[i]->vaddr);
        iounmap(hba[i]->vaddr);

-       cciss_unregister_scsi(i);  /* unhook from SCSI subsystem */
+       cciss_unregister_scsi(i);       /* unhook from SCSI subsystem */

        unregister_blkdev(hba[i]->major, hba[i]->devname);
        unregister_blkdev(hba[i]->major, hba[i]->devname);

-       remove_proc_entry(hba[i]->devname, proc_cciss); 
-       
+       remove_proc_entry(hba[i]->devname, proc_cciss);
+

        /* remove it from the disk list */
        /* remove it from the disk list */

-       for (j = 0; j < NWD; j++) {
+       for (j = 0; j < CISS_MAX_LUN; j++) {

                struct gendisk *disk = hba[i]->gendisk[j];
                if (disk) {
                        request_queue_t *q = disk->queue;
 
                struct gendisk *disk = hba[i]->gendisk[j];
                if (disk) {
                        request_queue_t *q = disk->queue;
 

-                       if (disk->flags & GENHD_FL_UP) 
+                       if (disk->flags & GENHD_FL_UP)

                                del_gendisk(disk);
                        if (q)
                                blk_cleanup_queue(q);
                }
        }
 
                                del_gendisk(disk);
                        if (q)
                                blk_cleanup_queue(q);
                }
        }
 

-       pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
+       pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),

                            hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
                            hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);

-       pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
-               hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
+       pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
+                           hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);

        kfree(hba[i]->cmd_pool_bits);
 #ifdef CONFIG_CISS_SCSI_TAPE
        kfree(hba[i]->scsi_rejects.complete);
 #endif
        kfree(hba[i]->cmd_pool_bits);
 #ifdef CONFIG_CISS_SCSI_TAPE
        kfree(hba[i]->scsi_rejects.complete);
 #endif

-       release_io_mem(hba[i]);
+       /*
+        * Deliberately omit pci_disable_device(): it does something nasty to
+        * Smart Array controllers that pci_enable_device does not undo
+        */
+       pci_release_regions(pdev);
+       pci_set_drvdata(pdev, NULL);

        free_hba(i);
        free_hba(i);

-}      
+}

 
 static struct pci_driver cciss_pci_driver = {
 
 static struct pci_driver cciss_pci_driver = {

-       .name =         "cciss",
-       .probe =        cciss_init_one,
-       .remove =       __devexit_p(cciss_remove_one),
-       .id_table =     cciss_pci_device_id, /* id_table */
+       .name = "cciss",
+       .probe = cciss_init_one,
+       .remove = __devexit_p(cciss_remove_one),
+       .id_table = cciss_pci_device_id,        /* id_table */

 };
 
 /*
  *  This is it.  Register the PCI driver information for the cards we control
 };
 
 /*
  *  This is it.  Register the PCI driver information for the cards we control

- *  the OS will call our registered routines when it finds one of our cards. 
+ *  the OS will call our registered routines when it finds one of our cards.

  */
 static int __init cciss_init(void)
 {
  */
 static int __init cciss_init(void)
 {


@@ -3378,12 +3493,10 @@ static void __exit cciss_cleanup(void)
 
        pci_unregister_driver(&cciss_pci_driver);
        /* double check that all controller entrys have been removed */
 
        pci_unregister_driver(&cciss_pci_driver);
        /* double check that all controller entrys have been removed */

-       for (i=0; i< MAX_CTLR; i++) 
-       {
-               if (hba[i] != NULL)
-               {
+       for (i = 0; i < MAX_CTLR; i++) {
+               if (hba[i] != NULL) {

                        printk(KERN_WARNING "cciss: had to remove"
                        printk(KERN_WARNING "cciss: had to remove"

-                                       " controller %d\n", i);
+                              " controller %d\n", i);

                        cciss_remove_one(hba[i]->pdev);
                }
        }
                        cciss_remove_one(hba[i]->pdev);
                }
        }


@@ -3398,21 +3511,21 @@ static void fail_all_cmds(unsigned long ctlr)
        unsigned long flags;
 
        printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
        unsigned long flags;
 
        printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);

-       h->alive = 0;   /* the controller apparently died... */
+       h->alive = 0;           /* the controller apparently died... */

 
        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 
 
        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 

-       pci_disable_device(h->pdev); /* Make sure it is really dead. */
+       pci_disable_device(h->pdev);    /* Make sure it is really dead. */

 
        /* move everything off the request queue onto the completed queue */
 
        /* move everything off the request queue onto the completed queue */

-       while( (c = h->reqQ) != NULL ) {
+       while ((c = h->reqQ) != NULL) {

                removeQ(&(h->reqQ), c);
                h->Qdepth--;
                removeQ(&(h->reqQ), c);
                h->Qdepth--;

-               addQ (&(h->cmpQ), c);
+               addQ(&(h->cmpQ), c);

        }
 
        /* Now, fail everything on the completed queue with a HW error */
        }
 
        /* Now, fail everything on the completed queue with a HW error */

-       while( (c = h->cmpQ) != NULL ) {
+       while ((c = h->cmpQ) != NULL) {

                removeQ(&h->cmpQ, c);
                c->err_info->CommandStatus = CMD_HARDWARE_ERR;
                if (c->cmd_type == CMD_RWREQ) {
                removeQ(&h->cmpQ, c);
                c->err_info->CommandStatus = CMD_HARDWARE_ERR;
                if (c->cmd_type == CMD_RWREQ) {


@@ -3420,8 +3533,8 @@ static void fail_all_cmds(unsigned long ctlr)
                } else if (c->cmd_type == CMD_IOCTL_PEND)
                        complete(c->waiting);
 #ifdef CONFIG_CISS_SCSI_TAPE
                } else if (c->cmd_type == CMD_IOCTL_PEND)
                        complete(c->waiting);
 #ifdef CONFIG_CISS_SCSI_TAPE

-                       else if (c->cmd_type == CMD_SCSI)
-                               complete_scsi_command(c, 0, 0);
+               else if (c->cmd_type == CMD_SCSI)
+                       complete_scsi_command(c, 0, 0);

 #endif
        }
        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 #endif
        }
        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);