Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]

Diff markup

Differences between /linux/drivers/base/power/resume.c (Version 2.6.11.8) and /linux/drivers/base/power/resume.c (Version 2.6.31.13)


  1 /*                                                  1 
  2  * resume.c - Functions for waking devices up.    
  3  *                                                
  4  * Copyright (c) 2003 Patrick Mochel              
  5  * Copyright (c) 2003 Open Source Development     
  6  *                                                
  7  * This file is released under the GPLv2          
  8  *                                                
  9  */                                               
 10                                                   
 11 #include <linux/device.h>                         
 12 #include "power.h"                                
 13                                                   
 14 extern int sysdev_resume(void);                   
 15                                                   
 16                                                   
 17 /**                                               
 18  *      resume_device - Restore state for one     
 19  *      @dev:   Device.                           
 20  *                                                
 21  */                                               
 22                                                   
 23 int resume_device(struct device * dev)            
 24 {                                                 
 25         if (dev->bus && dev->bus->resume)         
 26                 return dev->bus->resume(dev);     
 27         return 0;                                 
 28 }                                                 
 29                                                   
 30                                                   
 31                                                   
 32 void dpm_resume(void)                             
 33 {                                                 
 34         down(&dpm_list_sem);                      
 35         while(!list_empty(&dpm_off)) {            
 36                 struct list_head * entry = dpm    
 37                 struct device * dev = to_devic    
 38                                                   
 39                 get_device(dev);                  
 40                 list_del_init(entry);             
 41                 list_add_tail(entry, &dpm_acti    
 42                                                   
 43                 up(&dpm_list_sem);                
 44                 if (!dev->power.prev_state)       
 45                         resume_device(dev);       
 46                 down(&dpm_list_sem);              
 47                 put_device(dev);                  
 48         }                                         
 49         up(&dpm_list_sem);                        
 50 }                                                 
 51                                                   
 52                                                   
 53 /**                                               
 54  *      device_resume - Restore state of each     
 55  *                                                
 56  *      Walk the dpm_off list, remove each ent    
 57  *      then add it to the dpm_active list.       
 58  */                                               
 59                                                   
 60 void device_resume(void)                          
 61 {                                                 
 62         down(&dpm_sem);                           
 63         dpm_resume();                             
 64         up(&dpm_sem);                             
 65 }                                                 
 66                                                   
 67 EXPORT_SYMBOL_GPL(device_resume);                 
 68                                                   
 69                                                   
 70 /**                                               
 71  *      device_power_up_irq - Power on some de    
 72  *                                                
 73  *      Walk the dpm_off_irq list and power ea    
 74  *      is used for devices that required they    
 75  *      interrupts disabled. As devices are po    
 76  *      the dpm_suspended list.                   
 77  *                                                
 78  *      Interrupts must be disabled when calli    
 79  */                                               
 80                                                   
 81 void dpm_power_up(void)                           
 82 {                                                 
 83         while(!list_empty(&dpm_off_irq)) {        
 84                 struct list_head * entry = dpm    
 85                 struct device * dev = to_devic    
 86                                                   
 87                 get_device(dev);                  
 88                 list_del_init(entry);             
 89                 list_add_tail(entry, &dpm_acti    
 90                 resume_device(dev);               
 91                 put_device(dev);                  
 92         }                                         
 93 }                                                 
 94                                                   
 95                                                   
 96 /**                                               
 97  *      device_pm_power_up - Turn on all devic    
 98  *                                                
 99  *      Power on system devices then devices t    
100  *      with interrupts disabled.                 
101  *      Called with interrupts disabled.          
102  */                                               
103                                                   
104 void device_power_up(void)                        
105 {                                                 
106         sysdev_resume();                          
107         dpm_power_up();                           
108 }                                                 
109                                                   
110 EXPORT_SYMBOL_GPL(device_power_up);               
111                                                   
112                                                   
113                                                   
  This page was automatically generated by the LXR engine.