Zap line-endings

1 files changed, 71 insertions, 71 deletions

diff --git a/litmus/nvidia_info.c b/litmus/nvidia_info.c
index fd6398121fbf..889313c854e6 100644
--- a/litmus/nvidia_info.c
+++ b/litmus/nvidia_info.c
@@ -41,10 +41,10 @@ typedef struct
 {
     void  *priv;                    /* private data */
     void  *os_state;                /* os-specific device state */
-        
+
     int    rmInitialized;
     int    flags;
-        
+
     /* PCI config info */
     NvU32 domain;
     NvU16 bus;
@@ -54,31 +54,31 @@ typedef struct
     NvU16 subsystem_id;
     NvU32 gpu_id;
     void *handle;
-        
+
     NvU32 pci_cfg_space[16];
-        
+
     /* physical characteristics */
     litmus_nv_aperture_t bars[3];
     litmus_nv_aperture_t *regs;
     litmus_nv_aperture_t *fb, ud;
     litmus_nv_aperture_t agp;
-        
+
     NvU32  interrupt_line;
-        
+
     NvU32 agp_config;
     NvU32 agp_status;
-        
+
     NvU32 primary_vga;
-        
+
     NvU32 sim_env;
-        
+
     NvU32 rc_timer_enabled;
-        
+
     /* list of events allocated for this device */
     void *event_list;
-        
+
     void *kern_mappings;
-        
+
 } litmus_nv_state_t;
 
 typedef struct work_struct litmus_nv_task_t;
@@ -91,11 +91,11 @@ typedef struct litmus_nv_work_s {
 typedef struct litmus_nv_linux_state_s {
     litmus_nv_state_t nv_state;
     atomic_t usage_count;
-        
+
     struct pci_dev *dev;
     void *agp_bridge;
     void *alloc_queue;
-        
+
     void *timer_sp;
     void *isr_sp;
     void *pci_cfgchk_sp;
@@ -108,29 +108,29 @@ typedef struct litmus_nv_linux_state_s {
     /* keep track of any pending bottom halfes */
     struct tasklet_struct tasklet;
     litmus_nv_work_t work;
-        
+
     /* get a timer callback every second */
     struct timer_list rc_timer;
-        
+
     /* lock for linux-specific data, not used by core rm */
     struct semaphore ldata_lock;
-        
+
     /* lock for linux-specific alloc queue */
     struct semaphore at_lock;
-        
+
 #if 0
 #if defined(NV_USER_MAP)
     /* list of user mappings */
     struct nv_usermap_s *usermap_list;
-        
+
     /* lock for VMware-specific mapping list */
     struct semaphore mt_lock;
-#endif /* defined(NV_USER_MAP) */       
+#endif /* defined(NV_USER_MAP) */
 #if defined(NV_PM_SUPPORT_OLD_STYLE_APM)
         void *apm_nv_dev;
 #endif
 #endif
-        
+
     NvU32 device_num;
     struct litmus_nv_linux_state_s *next;
 } litmus_nv_linux_state_t;
@@ -140,9 +140,9 @@ void dump_nvidia_info(const struct tasklet_struct *t)
         litmus_nv_state_t* nvstate = NULL;
         litmus_nv_linux_state_t* linuxstate =  NULL;
         struct pci_dev* pci = NULL;
-        
+
         nvstate = (litmus_nv_state_t*)(t->data);
-        
+
         if(nvstate)
         {
                 TRACE("NV State:\n"
@@ -170,21 +170,21 @@ void dump_nvidia_info(const struct tasklet_struct *t)
                           nvstate->subsystem_id,
                           nvstate->gpu_id,
                           nvstate->interrupt_line);
-                
+
                 linuxstate = container_of(nvstate, litmus_nv_linux_state_t, nv_state);
         }
         else
         {
                 TRACE("INVALID NVSTATE????\n");
         }
-        
+
         if(linuxstate)
         {
                 int ls_offset = (void*)(&(linuxstate->device_num)) - (void*)(linuxstate);
                 int ns_offset_raw = (void*)(&(linuxstate->device_num)) - (void*)(&(linuxstate->nv_state));
                 int ns_offset_desired = (void*)(&(linuxstate->device_num)) - (void*)(nvstate);
-                
-                
+
+
                 TRACE("LINUX NV State:\n"
                           "\tlinux nv state ptr: %p\n"
                           "\taddress of tasklet: %p\n"
@@ -200,9 +200,9 @@ void dump_nvidia_info(const struct tasklet_struct *t)
                           linuxstate->device_num,
                           (t == &(linuxstate->tasklet)),
                           linuxstate->dev);
-                
+
                 pci = linuxstate->dev;
-                
+
                 TRACE("Offsets:\n"
                           "\tOffset from LinuxState: %d, %x\n"
                           "\tOffset from NVState: %d, %x\n"
@@ -249,7 +249,7 @@ int init_nvidia_info(void)
 {
         mutex_lock(&module_mutex);
         nvidia_mod = find_module("nvidia");
-        mutex_unlock(&module_mutex);    
+        mutex_unlock(&module_mutex);
         if(nvidia_mod != NULL)
         {
                 TRACE("%s : Found NVIDIA module. Core Code: %p to %p\n", __FUNCTION__,
@@ -280,7 +280,7 @@ int is_nvidia_func(void* func_addr)
                                 __FUNCTION__, func_addr, ret);
                 }*/
         }
-        
+
         return(ret);
 }
 
@@ -303,7 +303,7 @@ u32 get_tasklet_nv_device_num(const struct tasklet_struct *t)
 
         void* state = (void*)(t->data);
         void* device_num_ptr = state + DEVICE_NUM_OFFSET;
-        
+
         //dump_nvidia_info(t);
         return(*((u32*)device_num_ptr));
 #endif
@@ -334,14 +334,14 @@ static nv_device_registry_t NV_DEVICE_REG[NV_DEVICE_NUM];
 int init_nv_device_reg(void)
 {
         int i;
-        
+
         memset(NV_DEVICE_REG, 0, sizeof(NV_DEVICE_REG));
-        
+
         for(i = 0; i < NV_DEVICE_NUM; ++i)
         {
                 raw_spin_lock_init(&NV_DEVICE_REG[i].lock);
         }
-                                 
+
         return(1);
 }
 
@@ -360,7 +360,7 @@ int get_nv_device_id(struct task_struct* owner)
                 if(NV_DEVICE_REG[i].device_owner == owner)
                         return(i);
         }
-        return(-1); 
+        return(-1);
 }
 */
 
@@ -380,42 +380,42 @@ void pai_check_priority_increase(struct task_struct *t, int reg_device_id)
 {
         unsigned long flags;
         nv_device_registry_t *reg = &NV_DEVICE_REG[reg_device_id];
-        
+
         if(reg->max_prio_owner != t) {
-                
+
                 raw_spin_lock_irqsave(&reg->lock, flags);
-                
+
                 if(reg->max_prio_owner != t) {
                         if(litmus->compare(t, reg->max_prio_owner)) {
                                 litmus->change_prio_pai_tasklet(reg->max_prio_owner, t);
                                 reg->max_prio_owner = t;
                         }
                 }
-                
+
                 raw_spin_unlock_irqrestore(&reg->lock, flags);
         }
 }
-        
-                   
+
+
 void pai_check_priority_decrease(struct task_struct *t, int reg_device_id)
 {
         unsigned long flags;
         nv_device_registry_t *reg = &NV_DEVICE_REG[reg_device_id];
-        
+
         if(reg->max_prio_owner == t) {
-                
+
                 raw_spin_lock_irqsave(&reg->lock, flags);
-                
+
                 if(reg->max_prio_owner == t) {
                         reg->max_prio_owner = find_hp_owner(reg, NULL);
                         if(reg->max_prio_owner != t) {
                                 litmus->change_prio_pai_tasklet(t, reg->max_prio_owner);
                         }
                 }
-                
+
                 raw_spin_unlock_irqrestore(&reg->lock, flags);
         }
-}                  
+}
 #endif
 
 static int __reg_nv_device(int reg_device_id, struct task_struct *t)
@@ -430,30 +430,30 @@ static int __reg_nv_device(int reg_device_id, struct task_struct *t)
                 // TODO: check if taks is already registered.
                 return ret;  // assume already registered.
         }
-                        
+
         raw_spin_lock_irqsave(&reg->lock, flags);
-        
+
         if(reg->nr_owners < NV_MAX_SIMULT_USERS) {
                 TRACE_TASK(t, "registers GPU %d\n", reg_device_id);
                 for(i = 0; i < NV_MAX_SIMULT_USERS; ++i) {
                         if(reg->owners[i] == NULL) {
                                 reg->owners[i] = t;
-                                
+
                                 //if(edf_higher_prio(t, reg->max_prio_owner)) {
                                 if(litmus->compare(t, reg->max_prio_owner)) {
                                         old_max = reg->max_prio_owner;
                                         reg->max_prio_owner = t;
-                                        
+
 #ifdef CONFIG_LITMUS_PAI_SOFTIRQD
                                         litmus->change_prio_pai_tasklet(old_max, t);
-#endif                                          
+#endif
                                 }
-                                
+
 #ifdef CONFIG_LITMUS_SOFTIRQD
                                 down_and_set_stat(t, HELD, &tsk_rt(t)->klitirqd_sem);
-#endif                          
+#endif
                                 ++(reg->nr_owners);
-                                
+
                                 break;
                         }
                 }
@@ -461,13 +461,13 @@ static int __reg_nv_device(int reg_device_id, struct task_struct *t)
         else
         {
                 TRACE_CUR("%s: device %d is already in use!\n", __FUNCTION__, reg_device_id);
-                ret = -EBUSY;           
+                ret = -EBUSY;
         }
-        
+
         raw_spin_unlock_irqrestore(&reg->lock, flags);
-        
+
         __set_bit(reg_device_id, &tsk_rt(t)->held_gpus);
-        
+
         return(ret);
 }
 
@@ -476,43 +476,43 @@ static int __clear_reg_nv_device(int de_reg_device_id, struct task_struct *t)
         int ret = 0;
         int i;
         unsigned long flags;
-        nv_device_registry_t *reg = &NV_DEVICE_REG[de_reg_device_id];   
-        
+        nv_device_registry_t *reg = &NV_DEVICE_REG[de_reg_device_id];
+
 #ifdef CONFIG_LITMUS_SOFTIRQD
     struct task_struct* klitirqd_th = get_klitirqd(de_reg_device_id);
 #endif
-        
+
         WARN_ON(!test_bit(de_reg_device_id, &tsk_rt(t)->held_gpus));
 
         raw_spin_lock_irqsave(&reg->lock, flags);
-        
+
         TRACE_TASK(t, "unregisters GPU %d\n", de_reg_device_id);
-        
+
         for(i = 0; i < NV_MAX_SIMULT_USERS; ++i) {
                 if(reg->owners[i] == t) {
-#ifdef CONFIG_LITMUS_SOFTIRQD                   
+#ifdef CONFIG_LITMUS_SOFTIRQD
                         flush_pending(klitirqd_th, t);
 #endif
                         if(reg->max_prio_owner == t) {
                                 reg->max_prio_owner = find_hp_owner(reg, t);
 #ifdef CONFIG_LITMUS_PAI_SOFTIRQD
                                 litmus->change_prio_pai_tasklet(t, reg->max_prio_owner);
-#endif                                  
+#endif
                         }
 
-#ifdef CONFIG_LITMUS_SOFTIRQD                   
+#ifdef CONFIG_LITMUS_SOFTIRQD
                         up_and_set_stat(t, NOT_HELD, &tsk_rt(t)->klitirqd_sem);
 #endif
-                        
+
                         reg->owners[i] = NULL;
                         --(reg->nr_owners);
-                        
+
                         break;
                 }
         }
-        
+
         raw_spin_unlock_irqrestore(&reg->lock, flags);
-        
+
         __clear_bit(de_reg_device_id, &tsk_rt(t)->held_gpus);
 
         return(ret);