#include "drm_internal.h"
#include <drm/drm_syncobj.h>
+/* merge normal syncobj to timeline syncobj, the point interval is 1 */
+#define DRM_SYNCOBJ_BINARY_POINT 1
+
struct drm_syncobj_stub_fence {
struct dma_fence base;
spinlock_t lock;
.get_timeline_name = drm_syncobj_stub_fence_get_name,
};
+struct drm_syncobj_signal_pt {
+ struct dma_fence_array *fence_array;
+ u64 value;
+ struct list_head list;
+};
/**
* drm_syncobj_find - lookup and reference a sync object.
{
int ret;
- *fence = drm_syncobj_fence_get(syncobj);
- if (*fence)
+ ret = drm_syncobj_search_fence(syncobj, 0, 0, fence);
+ if (!ret)
return 1;
spin_lock(&syncobj->lock);
* have the lock, try one more time just to be sure we don't add a
* callback when a fence has already been set.
*/
- if (syncobj->fence) {
- *fence = dma_fence_get(rcu_dereference_protected(syncobj->fence,
- lockdep_is_held(&syncobj->lock)));
- ret = 1;
+ if (!list_empty(&syncobj->signal_pt_list)) {
+ spin_unlock(&syncobj->lock);
+ drm_syncobj_search_fence(syncobj, 0, 0, fence);
+ if (*fence)
+ return 1;
+ spin_lock(&syncobj->lock);
} else {
*fence = NULL;
drm_syncobj_add_callback_locked(syncobj, cb, func);
spin_unlock(&syncobj->lock);
}
+static void drm_syncobj_init(struct drm_syncobj *syncobj)
+{
+ spin_lock(&syncobj->lock);
+ syncobj->timeline_context = dma_fence_context_alloc(1);
+ syncobj->timeline = 0;
+ syncobj->signal_point = 0;
+ init_waitqueue_head(&syncobj->wq);
+
+ INIT_LIST_HEAD(&syncobj->signal_pt_list);
+ spin_unlock(&syncobj->lock);
+}
+
+static void drm_syncobj_fini(struct drm_syncobj *syncobj)
+{
+ struct drm_syncobj_signal_pt *signal_pt = NULL, *tmp;
+
+ spin_lock(&syncobj->lock);
+ list_for_each_entry_safe(signal_pt, tmp,
+ &syncobj->signal_pt_list, list) {
+ list_del(&signal_pt->list);
+ dma_fence_put(&signal_pt->fence_array->base);
+ kfree(signal_pt);
+ }
+ spin_unlock(&syncobj->lock);
+}
+
+static struct dma_fence
+*drm_syncobj_find_signal_pt_for_point(struct drm_syncobj *syncobj,
+ uint64_t point)
+{
+ struct drm_syncobj_signal_pt *signal_pt;
+
+ if ((syncobj->type == DRM_SYNCOBJ_TYPE_TIMELINE) &&
+ (point <= syncobj->timeline)) {
+ struct drm_syncobj_stub_fence *fence =
+ kzalloc(sizeof(struct drm_syncobj_stub_fence),
+ GFP_KERNEL);
+
+ if (!fence)
+ return NULL;
+ spin_lock_init(&fence->lock);
+ dma_fence_init(&fence->base,
+ &drm_syncobj_stub_fence_ops,
+ &fence->lock,
+ syncobj->timeline_context,
+ point);
+
+ dma_fence_signal(&fence->base);
+ return &fence->base;
+ }
+
+ list_for_each_entry(signal_pt, &syncobj->signal_pt_list, list) {
+ if (point > signal_pt->value)
+ continue;
+ if ((syncobj->type == DRM_SYNCOBJ_TYPE_BINARY) &&
+ (point != signal_pt->value))
+ continue;
+ return dma_fence_get(&signal_pt->fence_array->base);
+ }
+ return NULL;
+}
+
+static int drm_syncobj_create_signal_pt(struct drm_syncobj *syncobj,
+ struct dma_fence *fence,
+ u64 point)
+{
+ struct drm_syncobj_signal_pt *signal_pt =
+ kzalloc(sizeof(struct drm_syncobj_signal_pt), GFP_KERNEL);
+ struct drm_syncobj_signal_pt *tail_pt;
+ struct dma_fence **fences;
+ int num_fences = 0;
+ int ret = 0, i;
+
+ if (!signal_pt)
+ return -ENOMEM;
+ if (!fence)
+ goto out;
+
+ fences = kmalloc_array(sizeof(void *), 2, GFP_KERNEL);
+ if (!fences) {
+ ret = -ENOMEM;
+ goto out;
+ }
+ fences[num_fences++] = dma_fence_get(fence);
+ /* timeline syncobj must take this dependency */
+ if (syncobj->type == DRM_SYNCOBJ_TYPE_TIMELINE) {
+ spin_lock(&syncobj->lock);
+ if (!list_empty(&syncobj->signal_pt_list)) {
+ tail_pt = list_last_entry(&syncobj->signal_pt_list,
+ struct drm_syncobj_signal_pt, list);
+ fences[num_fences++] =
+ dma_fence_get(&tail_pt->fence_array->base);
+ }
+ spin_unlock(&syncobj->lock);
+ }
+ signal_pt->fence_array = dma_fence_array_create(num_fences, fences,
+ syncobj->timeline_context,
+ point, false);
+ if (!signal_pt->fence_array) {
+ ret = -ENOMEM;
+ goto fail;
+ }
+
+ spin_lock(&syncobj->lock);
+ if (syncobj->signal_point >= point) {
+ DRM_WARN("A later signal is ready!");
+ spin_unlock(&syncobj->lock);
+ goto exist;
+ }
+ signal_pt->value = point;
+ list_add_tail(&signal_pt->list, &syncobj->signal_pt_list);
+ syncobj->signal_point = point;
+ spin_unlock(&syncobj->lock);
+ wake_up_all(&syncobj->wq);
+
+ return 0;
+exist:
+ dma_fence_put(&signal_pt->fence_array->base);
+fail:
+ for (i = 0; i < num_fences; i++)
+ dma_fence_put(fences[i]);
+ kfree(fences);
+out:
+ kfree(signal_pt);
+ return ret;
+}
+
+static void drm_syncobj_garbage_collection(struct drm_syncobj *syncobj)
+{
+ struct drm_syncobj_signal_pt *signal_pt, *tmp, *tail_pt;
+
+ spin_lock(&syncobj->lock);
+ tail_pt = list_last_entry(&syncobj->signal_pt_list,
+ struct drm_syncobj_signal_pt,
+ list);
+ list_for_each_entry_safe(signal_pt, tmp,
+ &syncobj->signal_pt_list, list) {
+ if (syncobj->type == DRM_SYNCOBJ_TYPE_BINARY &&
+ signal_pt == tail_pt)
+ continue;
+ if (dma_fence_is_signaled(&signal_pt->fence_array->base)) {
+ syncobj->timeline = signal_pt->value;
+ list_del(&signal_pt->list);
+ dma_fence_put(&signal_pt->fence_array->base);
+ kfree(signal_pt);
+ } else {
+ /*signal_pt is in order in list, from small to big, so
+ * the later must not be signal either */
+ break;
+ }
+ }
+
+ spin_unlock(&syncobj->lock);
+}
/**
* drm_syncobj_replace_fence - replace fence in a sync object.
* @syncobj: Sync object to replace fence in
u64 point,
struct dma_fence *fence)
{
- struct dma_fence *old_fence;
- struct drm_syncobj_cb *cur, *tmp;
-
- if (fence)
- dma_fence_get(fence);
-
- spin_lock(&syncobj->lock);
-
- old_fence = rcu_dereference_protected(syncobj->fence,
- lockdep_is_held(&syncobj->lock));
- rcu_assign_pointer(syncobj->fence, fence);
+ u64 pt_value = point;
+
+ drm_syncobj_garbage_collection(syncobj);
+ if (syncobj->type == DRM_SYNCOBJ_TYPE_BINARY) {
+ if (!fence) {
+ drm_syncobj_fini(syncobj);
+ drm_syncobj_init(syncobj);
+ return;
+ }
+ pt_value = syncobj->signal_point +
+ DRM_SYNCOBJ_BINARY_POINT;
+ }
+ drm_syncobj_create_signal_pt(syncobj, fence, pt_value);
+ if (fence) {
+ struct drm_syncobj_cb *cur, *tmp;
- if (fence != old_fence) {
+ spin_lock(&syncobj->lock);
list_for_each_entry_safe(cur, tmp, &syncobj->cb_list, node) {
list_del_init(&cur->node);
cur->func(syncobj, cur);
}
+ spin_unlock(&syncobj->lock);
}
-
- spin_unlock(&syncobj->lock);
-
- dma_fence_put(old_fence);
}
EXPORT_SYMBOL(drm_syncobj_replace_fence);
return 0;
}
+static int
+drm_syncobj_point_get(struct drm_syncobj *syncobj, u64 point, u64 flags,
+ struct dma_fence **fence)
+{
+ int ret = 0;
+
+ if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT) {
+ ret = wait_event_interruptible(syncobj->wq,
+ point <= syncobj->signal_point);
+ if (ret < 0)
+ return ret;
+ }
+ spin_lock(&syncobj->lock);
+ *fence = drm_syncobj_find_signal_pt_for_point(syncobj, point);
+ if (!*fence)
+ ret = -EINVAL;
+ spin_unlock(&syncobj->lock);
+ return ret;
+}
+
+/**
+ * drm_syncobj_search_fence - lookup and reference the fence in a sync object or
+ * in a timeline point
+ * @syncobj: sync object pointer
+ * @point: timeline point
+ * @flags: DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT or not
+ * @fence: out parameter for the fence
+ *
+ * if flags is DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT, the function will block
+ * here until specific timeline points is reached.
+ * if not, you need a submit thread and block in userspace until all future
+ * timeline points have materialized, only then you can submit to the kernel,
+ * otherwise, function will fail to return fence.
+ *
+ * Returns 0 on success or a negative error value on failure. On success @fence
+ * contains a reference to the fence, which must be released by calling
+ * dma_fence_put().
+ */
+int drm_syncobj_search_fence(struct drm_syncobj *syncobj, u64 point,
+ u64 flags, struct dma_fence **fence)
+{
+ u64 pt_value = point;
+
+ if (!syncobj)
+ return -ENOENT;
+
+ drm_syncobj_garbage_collection(syncobj);
+ if (syncobj->type == DRM_SYNCOBJ_TYPE_BINARY) {
+ /*BINARY syncobj always wait on last pt */
+ pt_value = syncobj->signal_point;
+
+ if (pt_value == 0)
+ pt_value += DRM_SYNCOBJ_BINARY_POINT;
+ }
+ return drm_syncobj_point_get(syncobj, pt_value, flags, fence);
+}
+EXPORT_SYMBOL(drm_syncobj_search_fence);
+
/**
* drm_syncobj_find_fence - lookup and reference the fence in a sync object
* @file_private: drm file private pointer
* @fence: out parameter for the fence
*
* This is just a convenience function that combines drm_syncobj_find() and
- * drm_syncobj_fence_get().
+ * drm_syncobj_lookup_fence().
*
* Returns 0 on success or a negative error value on failure. On success @fence
* contains a reference to the fence, which must be released by calling
struct dma_fence **fence)
{
struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
- int ret = 0;
-
- if (!syncobj)
- return -ENOENT;
+ int ret;
- *fence = drm_syncobj_fence_get(syncobj);
- if (!*fence) {
- ret = -EINVAL;
- }
+ ret = drm_syncobj_search_fence(syncobj, point, flags, fence);
drm_syncobj_put(syncobj);
return ret;
}
struct drm_syncobj *syncobj = container_of(kref,
struct drm_syncobj,
refcount);
- drm_syncobj_replace_fence(syncobj, 0, NULL);
+ drm_syncobj_fini(syncobj);
kfree(syncobj);
}
EXPORT_SYMBOL(drm_syncobj_free);
kref_init(&syncobj->refcount);
INIT_LIST_HEAD(&syncobj->cb_list);
spin_lock_init(&syncobj->lock);
+ if (flags & DRM_SYNCOBJ_CREATE_TYPE_TIMELINE)
+ syncobj->type = DRM_SYNCOBJ_TYPE_TIMELINE;
+ else
+ syncobj->type = DRM_SYNCOBJ_TYPE_BINARY;
+ drm_syncobj_init(syncobj);
if (flags & DRM_SYNCOBJ_CREATE_SIGNALED) {
ret = drm_syncobj_assign_null_handle(syncobj);
return -EOPNOTSUPP;
/* no valid flags yet */
- if (args->flags & ~DRM_SYNCOBJ_CREATE_SIGNALED)
+ if (args->flags & ~(DRM_SYNCOBJ_CREATE_SIGNALED |
+ DRM_SYNCOBJ_CREATE_TYPE_TIMELINE))
return -EINVAL;
return drm_syncobj_create_as_handle(file_private,
struct syncobj_wait_entry *wait =
container_of(cb, struct syncobj_wait_entry, syncobj_cb);
- /* This happens inside the syncobj lock */
- wait->fence = dma_fence_get(rcu_dereference_protected(syncobj->fence,
- lockdep_is_held(&syncobj->lock)));
+ drm_syncobj_search_fence(syncobj, 0, 0, &wait->fence);
+
wake_up_process(wait->task);
}
signaled_count = 0;
for (i = 0; i < count; ++i) {
entries[i].task = current;
- entries[i].fence = drm_syncobj_fence_get(syncobjs[i]);
+ drm_syncobj_search_fence(syncobjs[i], 0, 0,
+ &entries[i].fence);
if (!entries[i].fence) {
if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT) {
continue;
if (ret < 0)
return ret;
- for (i = 0; i < args->count_handles; i++)
- drm_syncobj_replace_fence(syncobjs[i], 0, NULL);
-
+ for (i = 0; i < args->count_handles; i++) {
+ drm_syncobj_fini(syncobjs[i]);
+ drm_syncobj_init(syncobjs[i]);
+ }
drm_syncobj_array_free(syncobjs, args->count_handles);
- return 0;
+ return ret;
}
int
struct drm_syncobj_cb;
+enum drm_syncobj_type {
+ DRM_SYNCOBJ_TYPE_BINARY,
+ DRM_SYNCOBJ_TYPE_TIMELINE
+};
+
/**
* struct drm_syncobj - sync object.
*
- * This structure defines a generic sync object which wraps a &dma_fence.
+ * This structure defines a generic sync object which is timeline based.
*/
struct drm_syncobj {
/**
*/
struct kref refcount;
/**
- * @fence:
- * NULL or a pointer to the fence bound to this object.
- *
- * This field should not be used directly. Use drm_syncobj_fence_get()
- * and drm_syncobj_replace_fence() instead.
+ * @type: indicate syncobj type
+ */
+ enum drm_syncobj_type type;
+ /**
+ * @wq: wait signal operation work queue
+ */
+ wait_queue_head_t wq;
+ /**
+ * @timeline_context: fence context used by timeline
*/
- struct dma_fence __rcu *fence;
+ u64 timeline_context;
/**
- * @cb_list: List of callbacks to call when the &fence gets replaced.
+ * @timeline: syncobj timeline value, which indicates point is signaled.
*/
+ u64 timeline;
+ /**
+ * @signal_point: which indicates the latest signaler point.
+ */
+ u64 signal_point;
+ /**
+ * @signal_pt_list: signaler point list.
+ */
+ struct list_head signal_pt_list;
+
+ /**
+ * @cb_list: List of callbacks to call when the &fence gets replaced.
+ */
struct list_head cb_list;
/**
- * @lock: Protects &cb_list and write-locks &fence.
+ * @lock: Protects syncobj list and write-locks &fence.
*/
spinlock_t lock;
/**
/**
* struct drm_syncobj_cb - callback for drm_syncobj_add_callback
* @node: used by drm_syncob_add_callback to append this struct to
- * &drm_syncobj.cb_list
+ * &drm_syncobj.cb_list
* @func: drm_syncobj_func_t to call
*
* This struct will be initialized by drm_syncobj_add_callback, additional
kref_put(&obj->refcount, drm_syncobj_free);
}
-/**
- * drm_syncobj_fence_get - get a reference to a fence in a sync object
- * @syncobj: sync object.
- *
- * This acquires additional reference to &drm_syncobj.fence contained in @obj,
- * if not NULL. It is illegal to call this without already holding a reference.
- * No locks required.
- *
- * Returns:
- * Either the fence of @obj or NULL if there's none.
- */
-static inline struct dma_fence *
-drm_syncobj_fence_get(struct drm_syncobj *syncobj)
-{
- struct dma_fence *fence;
-
- rcu_read_lock();
- fence = dma_fence_get_rcu_safe(&syncobj->fence);
- rcu_read_unlock();
-
- return fence;
-}
-
struct drm_syncobj *drm_syncobj_find(struct drm_file *file_private,
u32 handle);
void drm_syncobj_replace_fence(struct drm_syncobj *syncobj, u64 point,
int drm_syncobj_get_handle(struct drm_file *file_private,
struct drm_syncobj *syncobj, u32 *handle);
int drm_syncobj_get_fd(struct drm_syncobj *syncobj, int *p_fd);
+int drm_syncobj_search_fence(struct drm_syncobj *syncobj, u64 point, u64 flags,
+ struct dma_fence **fence);
#endif
projects / openwrt / staging / blogic.git / commitdiff