[SCSI] aacraid: remove pigs in space

I was amazed at how much embedded space was present in the aacraid
driver source files. Just selected five files from the set to clean up
for now and the attached patch swelled to 73K in size!

- Removed trailing space or tabs
- Removed spaces embedded within tabs
- Replaced leading 8 spaces with tabs
- Removed spaces before )
- Removed ClusterCommand as it was unused (noticed it as one triggered by above)
- Replaced scsi_status comparison with 0x02, to compare against SAM_STATUS_CHECK_CONDITION.
- Replaced a long series of spaces with tabs
- Replaced some simple if...defined() with ifdef/ifndef

Signed-off-by: Mark Salyzyn <aacraid@adaptec.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>

1 files changed, 100 insertions, 101 deletions

diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 6d88f30296e1..1dd2e57c3345 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -56,7 +56,7 @@
  *      Allocate and map the shared PCI space for the FIB blocks used to
  *      talk to the Adaptec firmware.
  */
- 
+
 static int fib_map_alloc(struct aac_dev *dev)
 {
         dprintk((KERN_INFO
@@ -109,14 +109,16 @@ int aac_fib_setup(struct aac_dev * dev)
         }
         if (i<0)
                 return -ENOMEM;
-                
+
         hw_fib = dev->hw_fib_va;
         hw_fib_pa = dev->hw_fib_pa;
         memset(hw_fib, 0, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB));
         /*
          *      Initialise the fibs
          */
-        for (i = 0, fibptr = &dev->fibs[i]; i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++, fibptr++) 
+        for (i = 0, fibptr = &dev->fibs[i];
+                i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB);
+                i++, fibptr++)
         {
                 fibptr->dev = dev;
                 fibptr->hw_fib_va = hw_fib;
@@ -148,13 +150,13 @@ int aac_fib_setup(struct aac_dev * dev)
  *      Allocate a fib from the adapter fib pool. If the pool is empty we
  *      return NULL.
  */
- 
+
 struct fib *aac_fib_alloc(struct aac_dev *dev)
 {
         struct fib * fibptr;
         unsigned long flags;
         spin_lock_irqsave(&dev->fib_lock, flags);
-        fibptr = dev->free_fib; 
+        fibptr = dev->free_fib;
         if(!fibptr){
                 spin_unlock_irqrestore(&dev->fib_lock, flags);
                 return fibptr;
@@ -184,7 +186,7 @@ struct fib *aac_fib_alloc(struct aac_dev *dev)
  *
  *      Frees up a fib and places it on the appropriate queue
  */
- 
+
 void aac_fib_free(struct fib *fibptr)
 {
         unsigned long flags;
@@ -205,10 +207,10 @@ void aac_fib_free(struct fib *fibptr)
 /**
  *      aac_fib_init    -       initialise a fib
  *      @fibptr: The fib to initialize
- *      
+ *
  *      Set up the generic fib fields ready for use
  */
- 
+
 void aac_fib_init(struct fib *fibptr)
 {
         struct hw_fib *hw_fib = fibptr->hw_fib_va;
@@ -228,12 +230,12 @@ void aac_fib_init(struct fib *fibptr)
  *      Will deallocate and return to the free pool the FIB pointed to by the
  *      caller.
  */
- 
+
 static void fib_dealloc(struct fib * fibptr)
 {
         struct hw_fib *hw_fib = fibptr->hw_fib_va;
         BUG_ON(hw_fib->header.StructType != FIB_MAGIC);
-        hw_fib->header.XferState = 0;        
+        hw_fib->header.XferState = 0;
 }
 
 /*
@@ -242,7 +244,7 @@ static void fib_dealloc(struct fib * fibptr)
  *      these routines and are the only routines which have a knowledge of the
  *       how these queues are implemented.
  */
- 
+
 /**
  *      aac_get_entry           -       get a queue entry
  *      @dev: Adapter
@@ -255,7 +257,7 @@ static void fib_dealloc(struct fib * fibptr)
  *      is full(no free entries) than no entry is returned and the function returns 0 otherwise 1 is
  *      returned.
  */
- 
+
 static int aac_get_entry (struct aac_dev * dev, u32 qid, struct aac_entry **entry, u32 * index, unsigned long *nonotify)
 {
         struct aac_queue * q;
@@ -280,26 +282,27 @@ static int aac_get_entry (struct aac_dev * dev, u32 qid, struct aac_entry **entr
                                 idx = ADAP_NORM_RESP_ENTRIES;
                 }
                 if (idx != le32_to_cpu(*(q->headers.consumer)))
-                        *nonotify = 1; 
+                        *nonotify = 1;
         }
 
         if (qid == AdapNormCmdQueue) {
-                if (*index >= ADAP_NORM_CMD_ENTRIES) 
+                if (*index >= ADAP_NORM_CMD_ENTRIES)
                         *index = 0; /* Wrap to front of the Producer Queue. */
         } else {
-                if (*index >= ADAP_NORM_RESP_ENTRIES) 
+                if (*index >= ADAP_NORM_RESP_ENTRIES)
                         *index = 0; /* Wrap to front of the Producer Queue. */
         }
 
-        if ((*index + 1) == le32_to_cpu(*(q->headers.consumer))) { /* Queue is full */
+        /* Queue is full */
+        if ((*index + 1) == le32_to_cpu(*(q->headers.consumer))) {
                 printk(KERN_WARNING "Queue %d full, %u outstanding.\n",
                                 qid, q->numpending);
                 return 0;
         } else {
-                *entry = q->base + *index;
+                *entry = q->base + *index;
                 return 1;
         }
-}   
+}
 
 /**
  *      aac_queue_get           -       get the next free QE
@@ -321,31 +324,29 @@ int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_fib * hw
 {
         struct aac_entry * entry = NULL;
         int map = 0;
-            
+
         if (qid == AdapNormCmdQueue) {
                 /*  if no entries wait for some if caller wants to */
-                while (!aac_get_entry(dev, qid, &entry, index, nonotify)) 
-                {
+                while (!aac_get_entry(dev, qid, &entry, index, nonotify)) {
                         printk(KERN_ERR "GetEntries failed\n");
                 }
-                /*
-                 *      Setup queue entry with a command, status and fib mapped
-                 */
-                entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
-                map = 1;
+                /*
+                 *      Setup queue entry with a command, status and fib mapped
+                 */
+                entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
+                map = 1;
         } else {
-                while(!aac_get_entry(dev, qid, &entry, index, nonotify)) 
-                {
+                while (!aac_get_entry(dev, qid, &entry, index, nonotify)) {
                         /* if no entries wait for some if caller wants to */
                 }
-                /*
-                 *      Setup queue entry with command, status and fib mapped
-                 */
-                entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
-                entry->addr = hw_fib->header.SenderFibAddress;
-                        /* Restore adapters pointer to the FIB */
+                /*
+                 *      Setup queue entry with command, status and fib mapped
+                 */
+                entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size));
+                entry->addr = hw_fib->header.SenderFibAddress;
+                        /* Restore adapters pointer to the FIB */
                 hw_fib->header.ReceiverFibAddress = hw_fib->header.SenderFibAddress;    /* Let the adapter now where to find its data */
-                map = 0;
+                map = 0;
         }
         /*
          *      If MapFib is true than we need to map the Fib and put pointers
@@ -357,8 +358,8 @@ int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_fib * hw
 }
 
 /*
- *      Define the highest level of host to adapter communication routines. 
- *      These routines will support host to adapter FS commuication. These 
+ *      Define the highest level of host to adapter communication routines.
+ *      These routines will support host to adapter FS commuication. These
  *      routines have no knowledge of the commuication method used. This level
  *      sends and receives FIBs. This level has no knowledge of how these FIBs
  *      get passed back and forth.
@@ -380,7 +381,7 @@ int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_fib * hw
  *      an event to wait on must be supplied. This event will be set when a
  *      response FIB is received from the adapter.
  */
- 
+
 int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
                 int priority, int wait, int reply, fib_callback callback,
                 void *callback_data)
@@ -393,13 +394,13 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned)))
                 return -EBUSY;
         /*
-         *      There are 5 cases with the wait and reponse requested flags. 
+         *      There are 5 cases with the wait and reponse requested flags.
          *      The only invalid cases are if the caller requests to wait and
          *      does not request a response and if the caller does not want a
          *      response and the Fib is not allocated from pool. If a response
          *      is not requesed the Fib will just be deallocaed by the DPC
          *      routine when the response comes back from the adapter. No
-         *      further processing will be done besides deleting the Fib. We 
+         *      further processing will be done besides deleting the Fib. We
          *      will have a debug mode where the adapter can notify the host
          *      it had a problem and the host can log that fact.
          */
@@ -415,7 +416,7 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         } else if (wait && reply) {
                 hw_fib->header.XferState |= cpu_to_le32(ResponseExpected);
                 FIB_COUNTER_INCREMENT(aac_config.NormalSent);
-        } 
+        }
         /*
          *      Map the fib into 32bits by using the fib number
          */
@@ -438,7 +439,7 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         hw_fib->header.Size = cpu_to_le16(sizeof(struct aac_fibhdr) + size);
         if (le16_to_cpu(hw_fib->header.Size) > le16_to_cpu(hw_fib->header.SenderSize)) {
                 return -EMSGSIZE;
-        }                
+        }
         /*
          *      Get a queue entry connect the FIB to it and send an notify
          *      the adapter a command is ready.
@@ -475,9 +476,9 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         aac_adapter_deliver(fibptr);
 
         /*
-         *      If the caller wanted us to wait for response wait now. 
+         *      If the caller wanted us to wait for response wait now.
          */
-    
+
         if (wait) {
                 spin_unlock_irqrestore(&fibptr->event_lock, flags);
                 /* Only set for first known interruptable command */
@@ -524,7 +525,7 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
                 }
                 spin_unlock_irqrestore(&fibptr->event_lock, flags);
                 BUG_ON(fibptr->done == 0);
-                        
+
                 if(unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
                         return -ETIMEDOUT;
                 return 0;
@@ -539,15 +540,15 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
                 return 0;
 }
 
-/** 
+/**
  *      aac_consumer_get        -       get the top of the queue
  *      @dev: Adapter
  *      @q: Queue
  *      @entry: Return entry
  *
  *      Will return a pointer to the entry on the top of the queue requested that
- *      we are a consumer of, and return the address of the queue entry. It does
- *      not change the state of the queue. 
+ *      we are a consumer of, and return the address of the queue entry. It does
+ *      not change the state of the queue.
  */
 
 int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entry **entry)
@@ -562,10 +563,10 @@ int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entr
                  *      the end of the queue, else we just use the entry
                  *      pointed to by the header index
                  */
-                if (le32_to_cpu(*q->headers.consumer) >= q->entries) 
-                        index = 0;              
+                if (le32_to_cpu(*q->headers.consumer) >= q->entries)
+                        index = 0;
                 else
-                        index = le32_to_cpu(*q->headers.consumer);
+                        index = le32_to_cpu(*q->headers.consumer);
                 *entry = q->base + index;
                 status = 1;
         }
@@ -589,12 +590,12 @@ void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid)
 
         if ((le32_to_cpu(*q->headers.producer)+1) == le32_to_cpu(*q->headers.consumer))
                 wasfull = 1;
-        
+
         if (le32_to_cpu(*q->headers.consumer) >= q->entries)
                 *q->headers.consumer = cpu_to_le32(1);
         else
                 *q->headers.consumer = cpu_to_le32(le32_to_cpu(*q->headers.consumer)+1);
-        
+
         if (wasfull) {
                 switch (qid) {
 
@@ -610,7 +611,7 @@ void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid)
                 }
                 aac_adapter_notify(dev, notify);
         }
-}        
+}
 
 /**
  *      aac_fib_adapter_complete        -       complete adapter issued fib
@@ -632,32 +633,32 @@ int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
         if (hw_fib->header.XferState == 0) {
                 if (dev->comm_interface == AAC_COMM_MESSAGE)
                         kfree (hw_fib);
-                return 0;
+                return 0;
         }
         /*
          *      If we plan to do anything check the structure type first.
-         */ 
-        if ( hw_fib->header.StructType != FIB_MAGIC ) {
+         */
+        if (hw_fib->header.StructType != FIB_MAGIC) {
                 if (dev->comm_interface == AAC_COMM_MESSAGE)
                         kfree (hw_fib);
-                return -EINVAL;
+                return -EINVAL;
         }
         /*
          *      This block handles the case where the adapter had sent us a
          *      command and we have finished processing the command. We
-         *      call completeFib when we are done processing the command 
-         *      and want to send a response back to the adapter. This will 
+         *      call completeFib when we are done processing the command
+         *      and want to send a response back to the adapter. This will
          *      send the completed cdb to the adapter.
          */
         if (hw_fib->header.XferState & cpu_to_le32(SentFromAdapter)) {
                 if (dev->comm_interface == AAC_COMM_MESSAGE) {
                         kfree (hw_fib);
                 } else {
-                        u32 index;
-                        hw_fib->header.XferState |= cpu_to_le32(HostProcessed);
+                        u32 index;
+                        hw_fib->header.XferState |= cpu_to_le32(HostProcessed);
                         if (size) {
                                 size += sizeof(struct aac_fibhdr);
-                                if (size > le16_to_cpu(hw_fib->header.SenderSize)) 
+                                if (size > le16_to_cpu(hw_fib->header.SenderSize))
                                         return -EMSGSIZE;
                                 hw_fib->header.Size = cpu_to_le16(size);
                         }
@@ -669,12 +670,11 @@ int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
                         if (!(nointr & (int)aac_config.irq_mod))
                                 aac_adapter_notify(dev, AdapNormRespQueue);
                 }
+        } else {
+                printk(KERN_WARNING "aac_fib_adapter_complete: "
+                        "Unknown xferstate detected.\n");
+                BUG();
         }
-        else 
-        {
-                printk(KERN_WARNING "aac_fib_adapter_complete: Unknown xferstate detected.\n");
-                BUG();
-        }   
         return 0;
 }
 
@@ -684,7 +684,7 @@ int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
  *
  *      Will do all necessary work to complete a FIB.
  */
- 
+
 int aac_fib_complete(struct fib *fibptr)
 {
         struct hw_fib * hw_fib = fibptr->hw_fib_va;
@@ -694,15 +694,15 @@ int aac_fib_complete(struct fib *fibptr)
          */
 
         if (hw_fib->header.XferState == 0)
-                return 0;
+                return 0;
         /*
          *      If we plan to do anything check the structure type first.
-         */ 
+         */
 
         if (hw_fib->header.StructType != FIB_MAGIC)
-                return -EINVAL;
+                return -EINVAL;
         /*
-         *      This block completes a cdb which orginated on the host and we 
+         *      This block completes a cdb which orginated on the host and we
          *      just need to deallocate the cdb or reinit it. At this point the
          *      command is complete that we had sent to the adapter and this
          *      cdb could be reused.
@@ -723,7 +723,7 @@ int aac_fib_complete(struct fib *fibptr)
                 fib_dealloc(fibptr);
         } else {
                 BUG();
-        }   
+        }
         return 0;
 }
 
@@ -743,7 +743,7 @@ void aac_printf(struct aac_dev *dev, u32 val)
         {
                 int length = val & 0xffff;
                 int level = (val >> 16) & 0xffff;
-                
+
                 /*
                  *      The size of the printfbuf is set in port.c
                  *      There is no variable or define for it
@@ -757,7 +757,7 @@ void aac_printf(struct aac_dev *dev, u32 val)
                 else
                         printk(KERN_INFO "%s:%s", dev->name, cp);
         }
-        memset(cp, 0,  256);
+        memset(cp, 0, 256);
 }
 
 
@@ -816,9 +816,9 @@ static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
                          */
 
                         if ((dev != NULL) && (dev->scsi_host_ptr != NULL)) {
-                                device = scsi_device_lookup(dev->scsi_host_ptr, 
-                                        CONTAINER_TO_CHANNEL(container), 
-                                        CONTAINER_TO_ID(container), 
+                                device = scsi_device_lookup(dev->scsi_host_ptr,
+                                        CONTAINER_TO_CHANNEL(container),
+                                        CONTAINER_TO_ID(container),
                                         CONTAINER_TO_LUN(container));
                                 if (device) {
                                         dev->fsa_dev[container].config_needed = CHANGE;
@@ -1184,13 +1184,13 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced)
         }
         (void)aac_get_adapter_info(aac);
         if ((quirks & AAC_QUIRK_34SG) && (host->sg_tablesize > 34)) {
-                host->sg_tablesize = 34;
-                host->max_sectors = (host->sg_tablesize * 8) + 112;
-        }
-        if ((quirks & AAC_QUIRK_17SG) && (host->sg_tablesize > 17)) {
-                host->sg_tablesize = 17;
-                host->max_sectors = (host->sg_tablesize * 8) + 112;
-        }
+                host->sg_tablesize = 34;
+                host->max_sectors = (host->sg_tablesize * 8) + 112;
+        }
+        if ((quirks & AAC_QUIRK_17SG) && (host->sg_tablesize > 17)) {
+                host->sg_tablesize = 17;
+                host->max_sectors = (host->sg_tablesize * 8) + 112;
+        }
         aac_get_config_status(aac, 1);
         aac_get_containers(aac);
         /*
@@ -1461,7 +1461,7 @@ out:
  *      until the queue is empty. When the queue is empty it will wait for
  *      more FIBs.
  */
- 
+
 int aac_command_thread(void *data)
 {
         struct aac_dev *dev = data;
@@ -1487,30 +1487,29 @@ int aac_command_thread(void *data)
         add_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait);
         set_current_state(TASK_INTERRUPTIBLE);
         dprintk ((KERN_INFO "aac_command_thread start\n"));
-        while(1) 
-        {
+        while (1) {
                 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags);
                 while(!list_empty(&(dev->queues->queue[HostNormCmdQueue].cmdq))) {
                         struct list_head *entry;
                         struct aac_aifcmd * aifcmd;
 
                         set_current_state(TASK_RUNNING);
-        
+
                         entry = dev->queues->queue[HostNormCmdQueue].cmdq.next;
                         list_del(entry);
-                
+
                         spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags);
                         fib = list_entry(entry, struct fib, fiblink);
                         /*
-                         *      We will process the FIB here or pass it to a 
-                         *      worker thread that is TBD. We Really can't 
+                         *      We will process the FIB here or pass it to a
+                         *      worker thread that is TBD. We Really can't
                          *      do anything at this point since we don't have
                          *      anything defined for this thread to do.
                          */
                         hw_fib = fib->hw_fib_va;
                         memset(fib, 0, sizeof(struct fib));
                         fib->type = FSAFS_NTC_FIB_CONTEXT;
-                        fib->size = sizeof( struct fib );
+                        fib->size = sizeof(struct fib);
                         fib->hw_fib_va = hw_fib;
                         fib->data = hw_fib->data;
                         fib->dev = dev;
@@ -1526,17 +1525,17 @@ int aac_command_thread(void *data)
                         } else {
                                 /* The u32 here is important and intended. We are using
                                    32bit wrapping time to fit the adapter field */
-                                   
+
                                 u32 time_now, time_last;
                                 unsigned long flagv;
                                 unsigned num;
                                 struct hw_fib ** hw_fib_pool, ** hw_fib_p;
                                 struct fib ** fib_pool, ** fib_p;
-                        
+
                                 /* Sniff events */
-                                if ((aifcmd->command == 
+                                if ((aifcmd->command ==
                                      cpu_to_le32(AifCmdEventNotify)) ||
-                                    (aifcmd->command == 
+                                    (aifcmd->command ==
                                      cpu_to_le32(AifCmdJobProgress))) {
                                         aac_handle_aif(dev, fib);
                                 }
@@ -1588,7 +1587,7 @@ int aac_command_thread(void *data)
                                 spin_lock_irqsave(&dev->fib_lock, flagv);
                                 entry = dev->fib_list.next;
                                 /*
-                                 * For each Context that is on the 
+                                 * For each Context that is on the
                                  * fibctxList, make a copy of the
                                  * fib, and then set the event to wake up the
                                  * thread that is waiting for it.
@@ -1613,7 +1612,7 @@ int aac_command_thread(void *data)
                                                  */
                                                 time_last = fibctx->jiffies;
                                                 /*
-                                                 * Has it been > 2 minutes 
+                                                 * Has it been > 2 minutes
                                                  * since the last read off
                                                  * the queue?
                                                  */
@@ -1644,7 +1643,7 @@ int aac_command_thread(void *data)
                                                  */
                                                 list_add_tail(&newfib->fiblink, &fibctx->fib_list);
                                                 fibctx->count++;
-                                                /* 
+                                                /*
                                                  * Set the event to wake up the
                                                  * thread that is waiting.
                                                  */