1 files changed, 100 insertions, 101 deletions

diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 6d88f30296e..1dd2e57c334 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.
                                                  */