libdrm/nouveau/nouveau_fence.c

   1 /*
   2  * Copyright 2007 Nouveau Project
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  18  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  19  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27
  28 #include "nouveau_private.h"
  29 #include "nouveau_dma.h"
  30
  31 static void
  32 nouveau_fence_del_unsignalled(struct nouveau_fence *fence)
  33 {
  34         struct nouveau_channel_priv *nvchan = nouveau_channel(fence->channel);
  35         struct nouveau_fence *le;
  36
  37         if (nvchan->fence_head == fence) {
  38                 nvchan->fence_head = nouveau_fence(fence)->next;
  39                 if (nvchan->fence_head == NULL)
  40                         nvchan->fence_tail = NULL;
  41                 return;
  42         }
  43
  44         le = nvchan->fence_head;
  45         while (le && nouveau_fence(le)->next != fence)
  46                 le = nouveau_fence(le)->next;
  47         assert(le && nouveau_fence(le)->next == fence);
  48         nouveau_fence(le)->next = nouveau_fence(fence)->next;
  49         if (nvchan->fence_tail == fence)
  50                 nvchan->fence_tail = le;
  51 }
  52
  53 static void
  54 nouveau_fence_del(struct nouveau_fence **fence)
  55 {
  56         struct nouveau_fence_priv *nvfence;
  57
  58         if (!fence || !*fence)
  59                 return;
  60         nvfence = nouveau_fence(*fence);
  61         *fence = NULL;
  62
  63         if (--nvfence->refcount)
  64                 return;
  65
  66         if (nvfence->emitted && !nvfence->signalled) {
  67                 if (nvfence->signal_cb) {
  68                         nvfence->refcount++;
  69                         nouveau_fence_wait((void *)&nvfence);
  70                         return;
  71                 }
  72
  73                 nouveau_fence_del_unsignalled(&nvfence->base);
  74         }
  75         free(nvfence);
  76 }
  77
  78 int
  79 nouveau_fence_new(struct nouveau_channel *chan, struct nouveau_fence **fence)
  80 {
  81         struct nouveau_fence_priv *nvfence;
  82
  83         if (!chan || !fence || *fence)
  84                 return -EINVAL;
  85
  86         nvfence = calloc(1, sizeof(struct nouveau_fence_priv));
  87         if (!nvfence)
  88                 return -ENOMEM;
  89         nvfence->base.channel = chan;
  90         nvfence->refcount = 1;
  91
  92         *fence = &nvfence->base;
  93         return 0;
  94 }
  95
  96 int
  97 nouveau_fence_ref(struct nouveau_fence *ref, struct nouveau_fence **fence)
  98 {
  99         if (!fence)
 100                 return -EINVAL;
 101
 102         if (ref)
 103                 nouveau_fence(ref)->refcount++;
 104
 105         if (*fence)
 106                 nouveau_fence_del(fence);
 107
 108         *fence = ref;
 109         return 0;
 110 }
 111
 112 int
 113 nouveau_fence_signal_cb(struct nouveau_fence *fence, void (*func)(void *),
 114                         void *priv)
 115 {
 116         struct nouveau_fence_priv *nvfence = nouveau_fence(fence);
 117         struct nouveau_fence_cb *cb;
 118
 119         if (!nvfence || !func)
 120                 return -EINVAL;
 121
 122         cb = malloc(sizeof(struct nouveau_fence_cb));
 123         if (!cb)
 124                 return -ENOMEM;
 125
 126         cb->func = func;
 127         cb->priv = priv;
 128         cb->next = nvfence->signal_cb;
 129         nvfence->signal_cb = cb;
 130         return 0;
 131 }
 132
 133 void
 134 nouveau_fence_emit(struct nouveau_fence *fence)
 135 {
 136         struct nouveau_channel_priv *nvchan = nouveau_channel(fence->channel);
 137         struct nouveau_fence_priv *nvfence = nouveau_fence(fence);
 138
 139         nvfence->emitted = 1;
 140         nvfence->sequence = ++nvchan->fence_sequence;
 141         if (nvfence->sequence == 0xffffffff)
 142                 printf("AII wrap unhandled\n");
 143
 144         if (!nvchan->fence_ntfy) {
 145                 /*XXX: assumes subc 0 is populated */
 146                 nouveau_dma_space(fence->channel, 2);
 147                 nouveau_dma_out  (fence->channel, 0x00040050);
 148                 nouveau_dma_out  (fence->channel, nvfence->sequence);
 149         }
 150         nouveau_dma_kickoff(fence->channel);
 151
 152         if (nvchan->fence_tail) {
 153                 nouveau_fence(nvchan->fence_tail)->next = fence;
 154         } else {
 155                 nvchan->fence_head = fence;
 156         }
 157         nvchan->fence_tail = fence;
 158 }
 159
 160 static void
 161 nouveau_fence_flush_seq(struct nouveau_channel *chan, uint32_t sequence)
 162 {
 163         struct nouveau_channel_priv *nvchan = nouveau_channel(chan);
 164
 165         while (nvchan->fence_head) {
 166                 struct nouveau_fence_priv *nvfence;
 167
 168                 nvfence = nouveau_fence(nvchan->fence_head);
 169                 if (nvfence->sequence > sequence)
 170                         break;
 171                 nouveau_fence_del_unsignalled(&nvfence->base);
 172                 nvfence->signalled = 1;
 173
 174                 if (nvfence->signal_cb) {
 175                         struct nouveau_fence *fence = NULL;
 176
 177                         nouveau_fence_ref(&nvfence->base, &fence);
 178
 179                         while (nvfence->signal_cb) {
 180                                 struct nouveau_fence_cb *cb;
 181
 182                                 cb = nvfence->signal_cb;
 183                                 nvfence->signal_cb = cb->next;
 184                                 cb->func(cb->priv);
 185                                 free(cb);
 186                         }
 187
 188                         nouveau_fence_ref(NULL, &fence);
 189                 }
 190         }
 191 }
 192
 193 void
 194 nouveau_fence_flush(struct nouveau_channel *chan)
 195 {
 196         struct nouveau_channel_priv *nvchan = nouveau_channel(chan);
 197
 198         if (!nvchan->fence_ntfy)
 199                 nouveau_fence_flush_seq(chan, *nvchan->ref_cnt);
 200 }
 201
 202 int
 203 nouveau_fence_wait(struct nouveau_fence **fence)
 204 {
 205         struct nouveau_fence_priv *nvfence;
 206         struct nouveau_channel_priv *nvchan;
 207
 208         if (!fence)
 209                 return -EINVAL;
 210
 211         nvfence = nouveau_fence(*fence);
 212         if (!nvfence)
 213                 return 0;
 214         nvchan = nouveau_channel(nvfence->base.channel);
 215
 216         if (nvfence->emitted) {
 217                 if (!nvfence->signalled && nvchan->fence_ntfy) {
 218                         struct nouveau_channel *chan = &nvchan->base;
 219                         int ret;
 220
 221                         /*XXX: NV04/NV05: Full sync + flush all fences */
 222                         nouveau_notifier_reset(nvchan->fence_ntfy, 0);
 223                         BEGIN_RING(chan, nvchan->fence_grobj, 0x0104, 1);
 224                         OUT_RING  (chan, 0);
 225                         BEGIN_RING(chan, nvchan->fence_grobj, 0x0100, 1);
 226                         OUT_RING  (chan, 0);
 227                         FIRE_RING (chan);
 228                         ret = nouveau_notifier_wait_status(nvchan->fence_ntfy,
 229                                                            0, 0, 2.0);
 230                         if (ret)
 231                                 return ret;
 232
 233                         nouveau_fence_flush_seq(chan, nvchan->fence_sequence);
 234                 }
 235
 236                 while (!nvfence->signalled)
 237                         nouveau_fence_flush(nvfence->base.channel);
 238         }
 239
 240         nouveau_fence_ref(NULL, fence);
 241         return 0;
 242 }
 243