LXR linux/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
  26struct 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 */
  38struct 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 */
  64struct 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
  83static 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 */
 104struct 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 */
 115void 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 */
 124void 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 */
 136struct fence *sync_pt_create(struct sync_timeline *parent, int size);
 137
 138#ifdef CONFIG_DEBUG_FS
 139
 140void sync_timeline_debug_add(struct sync_timeline *obj);
 141void sync_timeline_debug_remove(struct sync_timeline *obj);
 142void sync_file_debug_add(struct sync_file *fence);
 143void sync_file_debug_remove(struct sync_file *fence);
 144void 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 */
 155