dma-buf: explicitely note that dma-fence-chains use 64bit seqno

Instead of checking the upper values of the sequence number use an explicit
field in the dma_fence_ops structure to note if a sequence should be 32bit
or 64bit.

Signed-off-by: Christian König <christian.koenig@amd.com>
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Link: https://patchwork.freedesktop.org/patch/299655/

diff --git a/drivers/dma-buf/dma-fence-chain.c b/drivers/dma-buf/dma-fence-chain.c
index c729f98a7bd3320051b0c7cad7bf94dedfbb7d37..93c42078cb573fbd48c414eef2c693c9791eef9a 100644 (file)
--- a/drivers/dma-buf/dma-fence-chain.c
+++ b/drivers/dma-buf/dma-fence-chain.c
@@ -193,6 +193,7 @@ static void dma_fence_chain_release(struct dma_fence *fence)
 }
 
 const struct dma_fence_ops dma_fence_chain_ops = {
+       .use_64bit_seqno = true,
        .get_driver_name = dma_fence_chain_get_driver_name,
        .get_timeline_name = dma_fence_chain_get_timeline_name,
        .enable_signaling = dma_fence_chain_enable_signaling,
@@ -225,7 +226,7 @@ void dma_fence_chain_init(struct dma_fence_chain *chain,
        init_irq_work(&chain->work, dma_fence_chain_irq_work);
 
        /* Try to reuse the context of the previous chain node. */
-       if (prev_chain && __dma_fence_is_later(seqno, prev->seqno)) {
+       if (prev_chain && __dma_fence_is_later(seqno, prev->seqno, prev->ops)) {
                context = prev->context;
                chain->prev_seqno = prev->seqno;
        } else {

diff --git a/drivers/dma-buf/sw_sync.c b/drivers/dma-buf/sw_sync.c
index 32dcf7b4c9356833ceb23e33af61a7725493e664..119b2ffbc2c9d2a2054ab6081e2be72e5bdc659b 100644 (file)
--- a/drivers/dma-buf/sw_sync.c
+++ b/drivers/dma-buf/sw_sync.c
@@ -161,7 +161,7 @@ static bool timeline_fence_signaled(struct dma_fence *fence)
 {
        struct sync_timeline *parent = dma_fence_parent(fence);
 
-       return !__dma_fence_is_later(fence->seqno, parent->value);
+       return !__dma_fence_is_later(fence->seqno, parent->value, fence->ops);
 }
 
 static bool timeline_fence_enable_signaling(struct dma_fence *fence)

diff --git a/drivers/dma-buf/sync_file.c b/drivers/dma-buf/sync_file.c
index 4f6305ca52c8e96c006b29516486a4e0ba7d12f4..ed3fb6e5224c98a2d2e64458eec7a7c610f35dc0 100644 (file)
--- a/drivers/dma-buf/sync_file.c
+++ b/drivers/dma-buf/sync_file.c
@@ -258,7 +258,8 @@ static struct sync_file *sync_file_merge(const char *name, struct sync_file *a,
 
                        i_b++;
                } else {
-                       if (__dma_fence_is_later(pt_a->seqno, pt_b->seqno))
+                       if (__dma_fence_is_later(pt_a->seqno, pt_b->seqno,
+                                                pt_a->ops))
                                add_fence(fences, &i, pt_a);
                        else
                                add_fence(fences, &i, pt_b);

diff --git a/include/linux/dma-fence.h b/include/linux/dma-fence.h
index 6b788467b2e3b650d4688f036f5e28a90fea8938..974717d6ac0c49d365bf8ceb22bb7fb4c0e0ce01 100644 (file)
--- a/include/linux/dma-fence.h
+++ b/include/linux/dma-fence.h
@@ -111,6 +111,14 @@ struct dma_fence_cb {
  *
  */
 struct dma_fence_ops {
+       /**
+        * @use_64bit_seqno:
+        *
+        * True if this dma_fence implementation uses 64bit seqno, false
+        * otherwise.
+        */
+       bool use_64bit_seqno;
+
        /**
         * @get_driver_name:
         *
@@ -410,18 +418,19 @@ dma_fence_is_signaled(struct dma_fence *fence)
  * __dma_fence_is_later - return if f1 is chronologically later than f2
  * @f1: the first fence's seqno
  * @f2: the second fence's seqno from the same context
+ * @ops: dma_fence_ops associated with the seqno
  *
  * Returns true if f1 is chronologically later than f2. Both fences must be
  * from the same context, since a seqno is not common across contexts.
  */
-static inline bool __dma_fence_is_later(u64 f1, u64 f2)
+static inline bool __dma_fence_is_later(u64 f1, u64 f2,
+                                       const struct dma_fence_ops *ops)
 {
        /* This is for backward compatibility with drivers which can only handle
-        * 32bit sequence numbers. Use a 64bit compare when any of the higher
-        * bits are none zero, otherwise use a 32bit compare with wrap around
-        * handling.
+        * 32bit sequence numbers. Use a 64bit compare when the driver says to
+        * do so.
         */
-       if (upper_32_bits(f1) || upper_32_bits(f2))
+       if (ops->use_64bit_seqno)
                return f1 > f2;
 
        return (int)(lower_32_bits(f1) - lower_32_bits(f2)) > 0;
@@ -441,7 +450,7 @@ static inline bool dma_fence_is_later(struct dma_fence *f1,
        if (WARN_ON(f1->context != f2->context))
                return false;
 
-       return __dma_fence_is_later(f1->seqno, f2->seqno);
+       return __dma_fence_is_later(f1->seqno, f2->seqno, f1->ops);
 }
 
 /**