^2 V1 support for the i.MX6 processor family.
aboutsummaryrefslogblamecommitdiffstats
path: root/include/linux/workqueue.h
blob: f11100f964824c250b4eacb21e96e36640527ac6 (plain) (tree)
1
2
3
4
5
6
7
8
9
10









                                                 
                          
                          
                       


                        

                                                      
 





                                                                     

                                                                            


                                                                             
                                

                                                                               
     
                                                                          

      

                                    
                                                               
                                                               
                                                           
                                                              





                                                              






                                                                    
                             

                                              

                                                
          
                                                                   

                                                                   



                                                           
                                                                     
                                                          
                                                                         



                                                    

  
                    
                           
                               
                         


                                       

  


                                                                    
 

                                


                                




                                                                            



                                











                                                              
                                                                 
                                                                 
                                                                 
                                                                 
                                                                 






                                                                 


                                                                 


                                                                 
  
                                            
   
                                                                 
                                                                 
                                                                 

                   

                                                                 
 


                                                               

                                                                
                                                          
 


                                                                         
                                                                              

      
  
                                          
  
                                                              

                                                              
   
                     
                                                                         
                                                                         

                                                                         
                                                                         
                                                                         
                                                                            


                                                                         
     
                                                                         
                                                                         
                                                                         




                                                                         
 









                                                                 



                                                                 

                   

                                                                 
                                                                 


                                                                 
                                                                 




                                                                 




                                                                   
                                                               





                                                                             

                                 
 
   

                                                                              
   
                                  
                                                                
 
      
                                                                        
                                                                    
                                                                     
                                                                    
                                                             
                                                                        
 

                                                                            
                                                                         
                                                                        
                                                    
  
 


                                                                               
 













                                                                     




                                                                      



                                               
                                                  
 
                                

                                                                           

                     
                                                                 

                                                                 





                                                                 
                                                                 

                                                                 

     

                                                                        

      
                                                                 
                                              
                                                                 
                                                                           
                                                                 
                                                           


                                                           
                                                                             

                                                              

                                                                        
                                                                      

                                                                        
                                                         
                                       
                                                          
 
                                                   
                                                               
                                                                                 

                                                                       
                                                  

                            
                                                                      
 
                                                
                                                      
 





                                                                               

                                                                           

                                                                             
                                    
   
                                                                


                
                                           
                
                                                


                   














                                                                            
                                                               
 
                                              



                                                                   







                                                            

 







                                                                               
 





                                          


                                                      
 
      
/*
 * workqueue.h --- work queue handling for Linux.
 */

#ifndef _LINUX_WORKQUEUE_H
#define _LINUX_WORKQUEUE_H

#include <linux/timer.h>
#include <linux/linkage.h>
#include <linux/bitops.h>
#include <linux/lockdep.h>
#include <linux/threads.h>
#include <asm/atomic.h>

struct workqueue_struct;

struct work_struct;
typedef void (*work_func_t)(struct work_struct *work);

/*
 * The first word is the work queue pointer and the flags rolled into
 * one
 */
#define work_data_bits(work) ((unsigned long *)(&(work)->data))

enum {
	WORK_STRUCT_PENDING_BIT	= 0,	/* work item is pending execution */
	WORK_STRUCT_DELAYED_BIT	= 1,	/* work item is delayed */
	WORK_STRUCT_CWQ_BIT	= 2,	/* data points to cwq */
	WORK_STRUCT_LINKED_BIT	= 3,	/* next work is linked to this one */
#ifdef CONFIG_DEBUG_OBJECTS_WORK
	WORK_STRUCT_STATIC_BIT	= 4,	/* static initializer (debugobjects) */
	WORK_STRUCT_COLOR_SHIFT	= 5,	/* color for workqueue flushing */
#else
	WORK_STRUCT_COLOR_SHIFT	= 4,	/* color for workqueue flushing */
#endif

	WORK_STRUCT_COLOR_BITS	= 4,

	WORK_STRUCT_PENDING	= 1 << WORK_STRUCT_PENDING_BIT,
	WORK_STRUCT_DELAYED	= 1 << WORK_STRUCT_DELAYED_BIT,
	WORK_STRUCT_CWQ		= 1 << WORK_STRUCT_CWQ_BIT,
	WORK_STRUCT_LINKED	= 1 << WORK_STRUCT_LINKED_BIT,
#ifdef CONFIG_DEBUG_OBJECTS_WORK
	WORK_STRUCT_STATIC	= 1 << WORK_STRUCT_STATIC_BIT,
#else
	WORK_STRUCT_STATIC	= 0,
#endif

	/*
	 * The last color is no color used for works which don't
	 * participate in workqueue flushing.
	 */
	WORK_NR_COLORS		= (1 << WORK_STRUCT_COLOR_BITS) - 1,
	WORK_NO_COLOR		= WORK_NR_COLORS,

	/* special cpu IDs */
	WORK_CPU_UNBOUND	= NR_CPUS,
	WORK_CPU_NONE		= NR_CPUS + 1,
	WORK_CPU_LAST		= WORK_CPU_NONE,

	/*
	 * Reserve 7 bits off of cwq pointer w/ debugobjects turned
	 * off.  This makes cwqs aligned to 256 bytes and allows 15
	 * workqueue flush colors.
	 */
	WORK_STRUCT_FLAG_BITS	= WORK_STRUCT_COLOR_SHIFT +
				  WORK_STRUCT_COLOR_BITS,

	WORK_STRUCT_FLAG_MASK	= (1UL << WORK_STRUCT_FLAG_BITS) - 1,
	WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,
	WORK_STRUCT_NO_CPU	= WORK_CPU_NONE << WORK_STRUCT_FLAG_BITS,

	/* bit mask for work_busy() return values */
	WORK_BUSY_PENDING	= 1 << 0,
	WORK_BUSY_RUNNING	= 1 << 1,
};

struct work_struct {
	atomic_long_t data;
	struct list_head entry;
	work_func_t func;
#ifdef CONFIG_LOCKDEP
	struct lockdep_map lockdep_map;
#endif
};

#define WORK_DATA_INIT()	ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU)
#define WORK_DATA_STATIC_INIT()	\
	ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU | WORK_STRUCT_STATIC)

struct delayed_work {
	struct work_struct work;
	struct timer_list timer;
};

static inline struct delayed_work *to_delayed_work(struct work_struct *work)
{
	return container_of(work, struct delayed_work, work);
}

struct execute_work {
	struct work_struct work;
};

#ifdef CONFIG_LOCKDEP
/*
 * NB: because we have to copy the lockdep_map, setting _key
 * here is required, otherwise it could get initialised to the
 * copy of the lockdep_map!
 */
#define __WORK_INIT_LOCKDEP_MAP(n, k) \
	.lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k),
#else
#define __WORK_INIT_LOCKDEP_MAP(n, k)
#endif

#define __WORK_INITIALIZER(n, f) {				\
	.data = WORK_DATA_STATIC_INIT(),			\
	.entry	= { &(n).entry, &(n).entry },			\
	.func = (f),						\
	__WORK_INIT_LOCKDEP_MAP(#n, &(n))			\
	}

#define __DELAYED_WORK_INITIALIZER(n, f) {			\
	.work = __WORK_INITIALIZER((n).work, (f)),		\
	.timer = TIMER_INITIALIZER(NULL, 0, 0),			\