[PATCH] CCISS: run through Lindent

cciss is full of inconsistent style ("for (" vs.  "for(", lines that end with
whitespace, lines beginning with a mix of spaces & tabs, etc).

This patch changes only whitespace.

Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Acked-by: Jeff Garzik <jeff@garzik.org>
Acked-by: Mike Miller <mike.miller@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 1581 insertions, 1534 deletions

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 44cf001db271..d5c126d7d427 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -34,7 +34,7 @@
 #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>
@@ -64,141 +64,147 @@ MODULE_LICENSE("GPL");
 
 /* 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, 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},
 	{0,}
 };
+
 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
 
 /*  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
  */
 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},
+	{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},
 };
 
 /* How long to wait (in milliseconds) for board to go into simple mode */
-#define MAX_CONFIG_WAIT 30000 
+#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 NR_CMDS		 384 /* #commands that can be outstanding */
+#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
 
-
 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 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 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 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_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, unsigned int *total_size,
+				unsigned int *block_size);
+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);
 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 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) {}
-#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
 
-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
-	.compat_ioctl   = cciss_compat_ioctl,
+	.compat_ioctl = cciss_compat_ioctl,
 #endif
-	.revalidate_disk= cciss_revalidate,
+	.revalidate_disk = cciss_revalidate,
 };
 
 /*
@@ -206,28 +212,29 @@ static struct block_device_operations cciss_fops  = {
  */
 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 */
@@ -240,23 +247,24 @@ static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
 #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 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;
-        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
@@ -264,35 +272,35 @@ 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);
-	return -EBUSY;
+		return -EBUSY;
 	}
 	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"
+		       "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;
 	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;
 
@@ -303,25 +311,26 @@ static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
 
 		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;
-        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;
@@ -330,20 +339,23 @@ cciss_proc_write(struct file *file, const char __user *buffer,
 	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
-	if (len && cmd[len-1] == '\n')
+	if (len && cmd[len - 1] == '\n')
 		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;
 }
@@ -356,116 +368,113 @@ static void __devinit cciss_procinit(int i)
 {
 	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;
-        }
+	}
 
-	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;
 }
-#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
- * 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;
-	int i; 
+	int i;
 	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;
 
-		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));
-	} 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, 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);
 #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));
-		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));
-		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->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->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;
 
-	if( !got_from_pool)
-	{ 
+	if (!got_from_pool) {
 		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;
-		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)
 {
-	return disk->queue->queuedata; 
+	return disk->queue->queuedata;
 }
 
 static inline drive_info_struct *get_drv(struct gendisk *disk)
@@ -483,7 +492,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);
-#endif /* CCISS_DEBUG */ 
+#endif				/* CCISS_DEBUG */
 
 	if (host->busy_initializing || drv->busy_configuring)
 		return -EBUSY;
@@ -496,10 +505,10 @@ static int cciss_open(struct inode *inode, struct file *filep)
 	 * for "raw controller".
 	 */
 	if (drv->nr_blocks == 0) {
-		if (iminor(inode) != 0)	{ 	/* not node 0? */
+		if (iminor(inode) != 0) {	/* not node 0? */
 			/* 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;
@@ -512,6 +521,7 @@ static int cciss_open(struct inode *inode, struct file *filep)
 	host->usage_count++;
 	return 0;
 }
+
 /*
  * Close.  Sync first.
  */
@@ -521,8 +531,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
-	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--;
@@ -540,8 +551,10 @@ static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 	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)
 {
@@ -573,19 +586,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 *) 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;
-	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);
@@ -594,28 +614,38 @@ static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long ar
 	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;
-	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;
 }
 
-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 *) arg;
+	    (BIG_IOCTL32_Command_struct __user *) arg;
 	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;
-	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);
@@ -623,12 +653,14 @@ static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned
 	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;
-	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;
@@ -649,10 +681,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;
@@ -663,171 +695,193 @@ 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);
-#endif /* CCISS_DEBUG */ 
-	
-	switch(cmd) {
+#endif				/* CCISS_DEBUG */
+
+	switch (cmd) {
 	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:
-	{
-		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:
-        {
-                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:
-        {
-                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;
-        }
+		{
+			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;
+			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;
+		}
 
 	case CCISS_GETHEARTBEAT:
-        {
-                Heartbeat_type heartbeat;
-
-		if (!arg) return -EINVAL;
-                heartbeat = readl(&host->cfgtable->HeartBeat);
-                if (copy_to_user(argp, &heartbeat