/*
* GK20A Sync Framework Integration
*
* Copyright (c) 2014-2016, NVIDIA CORPORATION. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*/
#include "sync_gk20a.h"
#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/hrtimer.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <uapi/linux/nvgpu.h>
#include "../drivers/staging/android/sync.h"
#include "semaphore_gk20a.h"
static const struct sync_timeline_ops gk20a_sync_timeline_ops;
struct gk20a_sync_timeline {
struct sync_timeline obj;
u32 max;
u32 min;
};
/**
* The sync framework dups pts when merging fences. We share a single
* refcounted gk20a_sync_pt for each duped pt.
*/
struct gk20a_sync_pt {
struct kref refcount;
u32 thresh;
struct gk20a_semaphore *sema;
struct gk20a_sync_timeline *obj;
struct sync_fence *dep;
ktime_t dep_timestamp;
/*
* Use a spin lock here since it will have better performance
* than a mutex - there should be very little contention on this
* lock.
*/
spinlock_t lock;
};
struct gk20a_sync_pt_inst {
struct sync_pt pt;
struct gk20a_sync_pt *shared;
};
/**
* Check if the passed sync_fence is backed by a single GPU semaphore. In such
* cases we can short circuit a lot of SW involved in signaling pre-fences and
* post fences.
*
* For now reject multi-sync_pt fences. This could be changed in future. It
* would require that the sema fast path push a sema acquire for each semaphore
* in the fence.
*/
int gk20a_is_sema_backed_sync_fence(struct sync_fence *fence)
{
struct sync_timeline *t;
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0)
struct sync_pt *spt;
int i = 0;
if (list_empty(&fence->pt_list_head))
return 0;
list_for_each_entry(spt, &fence->pt_list_head, pt_list) {
i++;
if (i >= 2)
return 0;
}
spt = list_first_entry(&fence->pt_list_head, struct sync_pt, pt_list);
t = spt->parent;
#else
struct fence *pt = fence->cbs[0].sync_pt;
struct sync_pt *spt = sync_pt_from_fence(pt);
if (fence->num_fences != 1)
return 0;
if (spt == NULL)
return 0;
t = sync_pt_parent(spt);
#endif
if (t->ops == &gk20a_sync_timeline_ops)
return 1;
return 0;
}
struct gk20a_semaphore *gk20a_sync_fence_get_sema(struct sync_fence *f)
{
struct sync_pt *spt;
struct gk20a_sync_pt_inst *pti;
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0)
if (!f)
return NULL;
if (!gk20a_is_sema_backed_sync_fence(f))
return NULL;
spt = list_first_entry(&f->pt_list_head, struct sync_pt, pt_list);
#else
struct fence *pt;
if (!f)
return NULL;
if (!gk20a_is_sema_backed_sync_fence(f))
return NULL;
pt = f->cbs[0].sync_pt;
spt = sync_pt_from_fence(pt);
#endif
pti = container_of(spt, struct gk20a_sync_pt_inst, pt);
return pti->shared->sema;
}
/**
* Compares sync pt values a and b, both of which will trigger either before
* or after ref (i.e. a and b trigger before ref, or a and b trigger after
* ref). Supplying ref allows us to handle wrapping correctly.
*
* Returns -1 if a < b (a triggers before b)
* 0 if a = b (a and b trigger at the same time)
* 1 if a > b (b triggers before a)
*/
static int __gk20a_sync_pt_compare_ref(
u32 ref,
u32 a,
u32 b)
{
/*
* We normalize both a and b by subtracting ref from them.
* Denote the normalized values by a_n and b_n. Note that because
* of wrapping, a_n and/or b_n may be negative.
*
* The normalized values a_n and b_n satisfy:
* - a positive value triggers before a negative value
* - a smaller positive value triggers before a greater positive value
* - a smaller negative value (greater in absolute value) triggers
* before a greater negative value (smaller in absolute value).
*
* Thus we can just stick to unsigned arithmetic and compare
* (u32)a_n to (u32)b_n.
*
* Just to reiterate the possible cases:
*
* 1A) ...ref..a....b....
* 1B) ...ref..b....a....
* 2A) ...b....ref..a.... b_n < 0
* 2B) ...a....ref..b.... a_n > 0
* 3A) ...a....b....ref.. a_n < 0, b_n < 0
* 3A) ...b....a....ref.. a_n < 0, b_n < 0
*/
u32 a_n = a - ref;
u32 b_n = b - ref;
if (a_n < b_n)
return -1;
else if (a_n > b_n)
return 1;
else
return 0;
}
static struct gk20a_sync_pt *to_gk20a_sync_pt(struct sync_pt *pt)
{
struct gk20a_sync_pt_inst *pti =
container_of(pt, struct gk20a_sync_pt_inst, pt);
return pti->shared;
}
static struct gk20a_sync_timeline *to_gk20a_timeline(struct sync_timeline *obj)
{
if (WARN_ON(obj->ops != &gk20a_sync_timeline_ops))
return NULL;
return (struct gk20a_sync_timeline *)obj;
}
static void gk20a_sync_pt_free_shared(struct kref *ref)
{
struct gk20a_sync_pt *pt =
container_of(ref, struct gk20a_sync_pt, refcount);
if (pt->dep)
sync_fence_put(pt->dep);
if (pt->sema)
gk20a_semaphore_put(pt->sema);
kfree(pt);
}
static struct gk20a_sync_pt *gk20a_sync_pt_create_shared(
struct gk20a_sync_timeline *obj,
struct gk20a_semaphore *sema,
struct sync_fence *dependency)
{
struct gk20a_sync_pt *shared;
shared = kzalloc(sizeof(*shared), GFP_KERNEL);
if (!shared)
return NULL;
kref_init(&shared->refcount);
shared->obj = obj;
shared->sema = sema;
shared->thresh = ++obj->max; /* sync framework has a lock */
/* Store the dependency fence for this pt. */
if (dependency) {
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0)
if (dependency->status == 0)
#else
if (!atomic_read(&dependency->status))
#endif
shared->dep = dependency;
else {
shared->dep_timestamp = ktime_get();
sync_fence_put(dependency);
}
}
spin_lock_init(&shared->lock);
gk20a_semaphore_get(sema);
return shared;
}
static struct sync_pt *gk20a_sync_pt_create_inst(
struct gk20a_sync_timeline *obj,
struct gk20a_semaphore *sema,
struct sync_fence *dependency)
{
struct gk20a_sync_pt_inst *pti;
pti = (struct gk20a_sync_pt_inst *)
sync_pt_create(&obj->obj, sizeof(*pti));
if (!pti)
return NULL;
pti->shared = gk20a_sync_pt_create_shared(obj, sema, dependency);
if (!pti->shared) {
sync_pt_free(&pti->pt);
return NULL;
}
return &pti->pt;
}
static void gk20a_sync_pt_free_inst(struct sync_pt *sync_pt)
{
struct gk20a_sync_pt *pt = to_gk20a_sync_pt(sync_pt);
if (pt)
kref_put(&pt->refcount, gk20a_sync_pt_free_shared);
}
static struct sync_pt *gk20a_sync_pt_dup_inst(struct sync_pt *sync_pt)
{
struct gk20a_sync_pt_inst *pti;
struct gk20a_sync_pt *pt = to_gk20a_sync_pt(sync_pt);
pti = (struct gk20a_sync_pt_inst *)
sync_pt_create(&pt->obj->obj, sizeof(*pti));
if (!pti)
return NULL;
pti->shared = pt;
kref_get(&pt->refcount);
return &pti->pt;
}
/*
* This function must be able to run on the same sync_pt concurrently. This
* requires a lock to protect access to the sync_pt's internal data structures
* which are modified as a side effect of calling this function.
*/
static int gk20a_sync_pt_has_signaled(struct sync_pt *sync_pt)
{
struct gk20a_sync_pt *pt = to_gk20a_sync_pt(sync_pt);
struct gk20a_sync_timeline *obj = pt->obj;
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0)
struct sync_pt *pos;
#endif
bool signaled = true;
spin_lock(&pt->lock);
if (!pt->sema)
goto done;
/* Acquired == not realeased yet == active == not signaled. */
signaled = !gk20a_semaphore_is_acquired(pt->sema);
if (signaled) {
/* Update min if necessary. */
if (__gk20a_sync_pt_compare_ref(obj->max, pt->thresh,
obj->min) == 1)
obj->min = pt->thresh;
/* Release the dependency fence, but get its timestamp
* first.*/
if (pt->dep) {
s64 ns = 0;
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0)
struct list_head *dep_pts = &pt->dep->pt_list_head;
list_for_each_entry(pos, dep_pts, pt_list) {
ns = max(ns, ktime_to_ns(pos->timestamp));
}
#else
struct fence *fence;
int i;
for (i = 0; i < pt->dep->num_fences; i++) {
fence = pt->dep->cbs[i].sync_pt;
ns = max(ns, ktime_to_ns(fence->timestamp));
}
#endif
pt->dep_timestamp = ns_to_ktime(ns);
sync_fence_put(pt->dep);
pt->dep = NULL;
}
/* Release the semaphore to the pool. */
gk20a_semaphore_put(pt->sema);
pt->sema = NULL;
}
done:
spin_unlock(&pt->lock);
return signaled;
}
static inline ktime_t gk20a_sync_pt_duration(struct sync_pt *sync_pt)
{
struct gk20a_sync_pt *pt = to_gk20a_sync_pt(sync_pt);
if (!gk20a_sync_pt_has_signaled(sync_pt) || !pt->dep_timestamp.tv64)
return ns_to_ktime(0);
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0)
return ktime_sub(sync_pt->timestamp, pt->dep_timestamp);
#else
return ktime_sub(sync_pt->base.timestamp, pt->dep_timestamp);
#endif
}
static int gk20a_sync_pt_compare(struct sync_pt *a, struct sync_pt *b)
{
bool a_expired;
bool b_expired;
struct gk20a_sync_pt *pt_a = to_gk20a_sync_pt(a);
struct gk20a_sync_pt *pt_b = to_gk20a_sync_pt(b);
if (WARN_ON(pt_a->obj != pt_b->obj))
return 0;
/* Early out */
if (a == b)
return 0;
a_expired = gk20a_sync_pt_has_signaled(a);
b_expired = gk20a_sync_pt_has_signaled(b);
if (a_expired && !b_expired) {
/* Easy, a was earlier */
return -1;
} else if (!a_expired && b_expired) {
/* Easy, b was earlier */
return 1;
}
/* Both a and b are expired (trigger before min) or not
* expired (trigger after min), so we can use min
* as a reference value for __gk20a_sync_pt_compare_ref.
*/
return __gk20a_sync_pt_compare_ref(pt_a->obj->min,
pt_a->thresh, pt_b->thresh);
}
static u32 gk20a_sync_timeline_current(struct gk20a_sync_timeline *obj)
{
return obj->min;
}
static void gk20a_sync_timeline_value_str(struct sync_timeline *timeline,
char *str, int size)
{
struct gk20a_sync_timeline *obj =
(struct gk20a_sync_timeline *)timeline;
snprintf(str, size, "%d", gk20a_sync_timeline_current(obj));
}
static void gk20a_sync_pt_value_str_for_sema(struct gk20a_sync_pt *pt,
char *str, int size)
{
struct gk20a_semaphore *s = pt->sema;
snprintf(str, size, "S: c=%d [v=%u,r_v=%u]",
s->hw_sema->ch->hw_chid,
gk20a_semaphore_get_value(s),
gk20a_semaphore_read(s));
}
static void gk20a_sync_pt_value_str(struct sync_pt *sync_pt, char *str,
int size)
{
struct gk20a_sync_pt *pt = to_gk20a_sync_pt(sync_pt);
ktime_t dur = gk20a_sync_pt_duration(sync_pt);
if (pt->sema) {
gk20a_sync_pt_value_str_for_sema(pt, str, size);
return;
}
if (pt->dep) {
snprintf(str, size, "(dep: [%p] %s) %d",
pt->dep, pt->dep->name, pt->thresh);
} else if (dur.tv64) {
struct timeval tv = ktime_to_timeval(dur);
snprintf(str, size, "(took %ld.%03ld ms) %d",
tv.tv_sec * 1000 + tv.tv_usec / 1000,
tv.tv_usec % 1000,
pt->thresh);
} else {
snprintf(str, size, "%d", pt->thresh);
}
}
static int gk20a_sync_fill_driver_data(struct sync_pt *sync_pt,
void *data, int size)
{
struct gk20a_sync_pt_info info;
if (size < (int)sizeof(info))
return -ENOMEM;
info.hw_op_ns = ktime_to_ns(gk20a_sync_pt_duration(sync_pt));
memcpy(data, &info, sizeof(info));
return sizeof(info);
}
static const struct sync_timeline_ops gk20a_sync_timeline_ops = {
.driver_name = "gk20a_semaphore",
.dup = gk20a_sync_pt_dup_inst,
.has_signaled = gk20a_sync_pt_has_signaled,
.compare = gk20a_sync_pt_compare,
.free_pt = gk20a_sync_pt_free_inst,
.fill_driver_data = gk20a_sync_fill_driver_data,
.timeline_value_str = gk20a_sync_timeline_value_str,
.pt_value_str = gk20a_sync_pt_value_str,
};
/* Public API */
struct sync_fence *gk20a_sync_fence_fdget(int fd)
{
return sync_fence_fdget(fd);
}
void gk20a_sync_timeline_signal(struct sync_timeline *timeline)
{
sync_timeline_signal(timeline, 0);
}
void gk20a_sync_timeline_destroy(struct sync_timeline *timeline)
{
sync_timeline_destroy(timeline);
}
struct sync_timeline *gk20a_sync_timeline_create(
const char *fmt, ...)
{
struct gk20a_sync_timeline *obj;
char name[30];
va_list args;
va_start(args, fmt);
vsnprintf(name, sizeof(name), fmt, args);
va_end(args);
obj = (struct gk20a_sync_timeline *)
sync_timeline_create(&gk20a_sync_timeline_ops,
sizeof(struct gk20a_sync_timeline),
name);
if (!obj)
return NULL;
obj->max = 0;
obj->min = 0;
return &obj->obj;
}
struct sync_fence *gk20a_sync_fence_create(struct sync_timeline *obj,
struct gk20a_semaphore *sema,
struct sync_fence *dependency,
const char *fmt, ...)
{
char name[30];
va_list args;
struct sync_pt *pt;
struct sync_fence *fence;
struct gk20a_sync_timeline *timeline = to_gk20a_timeline(obj);
pt = gk20a_sync_pt_create_inst(timeline, sema, dependency);
if (pt == NULL)
return NULL;
va_start(args, fmt);
vsnprintf(name, sizeof(name), fmt, args);
va_end(args);
fence = sync_fence_create(name, pt);
if (fence == NULL) {
sync_pt_free(pt);
return NULL;
}
return fence;
}