drivers/staging/android/sync.h

   1 /*
   2  * include/linux/sync.h
   3  *
   4  * Copyright (C) 2012 Google, Inc.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  * GNU General Public License for more details.
  10  *
  11  */
  12
  13 #ifndef _LINUX_SYNC_H
  14 #define _LINUX_SYNC_H
  15
  16 #include <linux/types.h>
  17 #include <linux/kref.h>
  18 #include <linux/ktime.h>
  19 #include <linux/list.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/fence.h>
  22
  23 #include <linux/sync_file.h>
  24 #include <uapi/linux/sync_file.h>
  25
  26 struct sync_timeline;
  27
  28 /**
  29  * struct sync_timeline_ops - sync object implementation ops
  30  * @driver_name:        name of the implementation
  31  * @has_signaled:       returns:
  32  *                        1 if pt has signaled
  33  *                        0 if pt has not signaled
  34  *                       <0 on error
  35  * @timeline_value_str: fill str with the value of the sync_timeline's counter
  36  * @fence_value_str:    fill str with the value of the fence
  37  */
  38 struct sync_timeline_ops {
  39         const char *driver_name;
  40
  41         /* required */
  42         int (*has_signaled)(struct fence *fence);
  43
  44         /* optional */
  45         void (*timeline_value_str)(struct sync_timeline *timeline, char *str,
  46                                    int size);
  47
  48         /* optional */
  49         void (*fence_value_str)(struct fence *fence, char *str, int size);
  50 };
  51
  52 /**
  53  * struct sync_timeline - sync object
  54  * @kref:               reference count on fence.
  55  * @ops:                ops that define the implementation of the sync_timeline
  56  * @name:               name of the sync_timeline. Useful for debugging
  57  * @destroyed:          set when sync_timeline is destroyed
  58  * @child_list_head:    list of children sync_pts for this sync_timeline
  59  * @child_list_lock:    lock protecting @child_list_head, destroyed, and
  60  *                      fence.status
  61  * @active_list_head:   list of active (unsignaled/errored) sync_pts
  62  * @sync_timeline_list: membership in global sync_timeline_list
  63  */
  64 struct sync_timeline {
  65         struct kref             kref;
  66         const struct sync_timeline_ops  *ops;
  67         char                    name[32];
  68
  69         /* protected by child_list_lock */
  70         bool                    destroyed;
  71         int                     context, value;
  72
  73         struct list_head        child_list_head;
  74         spinlock_t              child_list_lock;
  75
  76         struct list_head        active_list_head;
  77
  78 #ifdef CONFIG_DEBUG_FS
  79         struct list_head        sync_timeline_list;
  80 #endif
  81 };
  82
  83 static inline struct sync_timeline *fence_parent(struct fence *fence)
  84 {
  85         return container_of(fence->lock, struct sync_timeline,
  86                             child_list_lock);
  87 }
  88
  89 /*
  90  * API for sync_timeline implementers
  91  */
  92
  93 /**
  94  * sync_timeline_create() - creates a sync object
  95  * @ops:        specifies the implementation ops for the object
  96  * @size:       size to allocate for this obj
  97  * @name:       sync_timeline name
  98  *
  99  * Creates a new sync_timeline which will use the implementation specified by
 100  * @ops.  @size bytes will be allocated allowing for implementation specific
 101  * data to be kept after the generic sync_timeline struct. Returns the
 102  * sync_timeline object or NULL in case of error.
 103  */
 104 struct sync_timeline *sync_timeline_create(const struct sync_timeline_ops *ops,
 105                                            int size, const char *name);
 106
 107 /**
 108  * sync_timeline_destroy() - destroys a sync object
 109  * @obj:        sync_timeline to destroy
 110  *
 111  * A sync implementation should call this when the @obj is going away
 112  * (i.e. module unload.)  @obj won't actually be freed until all its children
 113  * fences are freed.
 114  */
 115 void sync_timeline_destroy(struct sync_timeline *obj);
 116
 117 /**
 118  * sync_timeline_signal() - signal a status change on a sync_timeline
 119  * @obj:        sync_timeline to signal
 120  *
 121  * A sync implementation should call this any time one of it's fences
 122  * has signaled or has an error condition.
 123  */
 124 void sync_timeline_signal(struct sync_timeline *obj);
 125
 126 /**
 127  * sync_pt_create() - creates a sync pt
 128  * @parent:     fence's parent sync_timeline
 129  * @size:       size to allocate for this pt
 130  *
 131  * Creates a new fence as a child of @parent.  @size bytes will be
 132  * allocated allowing for implementation specific data to be kept after
 133  * the generic sync_timeline struct. Returns the fence object or
 134  * NULL in case of error.
 135  */
 136 struct fence *sync_pt_create(struct sync_timeline *parent, int size);
 137
 138 #ifdef CONFIG_DEBUG_FS
 139
 140 void sync_timeline_debug_add(struct sync_timeline *obj);
 141 void sync_timeline_debug_remove(struct sync_timeline *obj);
 142 void sync_file_debug_add(struct sync_file *fence);
 143 void sync_file_debug_remove(struct sync_file *fence);
 144 void sync_dump(void);
 145
 146 #else
 147 # define sync_timeline_debug_add(obj)
 148 # define sync_timeline_debug_remove(obj)
 149 # define sync_file_debug_add(fence)
 150 # define sync_file_debug_remove(fence)
 151 # define sync_dump()
 152 #endif
 153
 154 #endif /* _LINUX_SYNC_H */