LXR linux/drivers/gpu/drm/nouveau/core/core/engctx.c

   1/*
   2 * Copyright 2012 Red Hat Inc.
   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 COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 * OTHER DEALINGS IN THE SOFTWARE.
  21 *
  22 * Authors: Ben Skeggs
  23 */
  24
  25#include <core/object.h>
  26#include <core/namedb.h>
  27#include <core/handle.h>
  28#include <core/client.h>
  29#include <core/engctx.h>
  30
  31#include <subdev/vm.h>
  32
  33static inline int
  34nouveau_engctx_exists(struct nouveau_object *parent,
  35                      struct nouveau_engine *engine, void **pobject)
  36{
  37        struct nouveau_engctx *engctx;
  38        struct nouveau_object *parctx;
  39
  40        list_for_each_entry(engctx, &engine->contexts, head) {
  41                parctx = nv_pclass(nv_object(engctx), NV_PARENT_CLASS);
  42                if (parctx == parent) {
  43                        atomic_inc(&nv_object(engctx)->refcount);
  44                        *pobject = engctx;
  45                        return 1;
  46                }
  47        }
  48
  49        return 0;
  50}
  51
  52int
  53nouveau_engctx_create_(struct nouveau_object *parent,
  54                       struct nouveau_object *engobj,
  55                       struct nouveau_oclass *oclass,
  56                       struct nouveau_object *pargpu,
  57                       u32 size, u32 align, u32 flags,
  58                       int length, void **pobject)
  59{
  60        struct nouveau_client *client = nouveau_client(parent);
  61        struct nouveau_engine *engine = nv_engine(engobj);
  62        struct nouveau_object *engctx;
  63        unsigned long save;
  64        int ret;
  65
  66        /* check if this engine already has a context for the parent object,
  67         * and reference it instead of creating a new one
  68         */
  69        spin_lock_irqsave(&engine->lock, save);
  70        ret = nouveau_engctx_exists(parent, engine, pobject);
  71        spin_unlock_irqrestore(&engine->lock, save);
  72        if (ret)
  73                return ret;
  74
  75        /* create the new context, supports creating both raw objects and
  76         * objects backed by instance memory
  77         */
  78        if (size) {
  79                ret = nouveau_gpuobj_create_(parent, engobj, oclass,
  80                                             NV_ENGCTX_CLASS,
  81                                             pargpu, size, align, flags,
  82                                             length, pobject);
  83        } else {
  84                ret = nouveau_object_create_(parent, engobj, oclass,
  85                                             NV_ENGCTX_CLASS, length, pobject);
  86        }
  87
  88        engctx = *pobject;
  89        if (ret)
  90                return ret;
  91
  92        /* must take the lock again and re-check a context doesn't already
  93         * exist (in case of a race) - the lock had to be dropped before as
  94         * it's not possible to allocate the object with it held.
  95         */
  96        spin_lock_irqsave(&engine->lock, save);
  97        ret = nouveau_engctx_exists(parent, engine, pobject);
  98        if (ret) {
  99                spin_unlock_irqrestore(&engine->lock, save);
 100                nouveau_object_ref(NULL, &engctx);
 101                return ret;
 102        }
 103
 104        if (client->vm)
 105                atomic_inc(&client->vm->engref[nv_engidx(engobj)]);
 106        list_add(&nv_engctx(engctx)->head, &engine->contexts);
 107        nv_engctx(engctx)->addr = ~0ULL;
 108        spin_unlock_irqrestore(&engine->lock, save);
 109        return 0;
 110}
 111
 112void
 113nouveau_engctx_destroy(struct nouveau_engctx *engctx)
 114{
 115        struct nouveau_object *engobj = nv_object(engctx)->engine;
 116        struct nouveau_engine *engine = nv_engine(engobj);
 117        struct nouveau_client *client = nouveau_client(engctx);
 118        unsigned long save;
 119
 120        nouveau_gpuobj_unmap(&engctx->vma);
 121        spin_lock_irqsave(&engine->lock, save);
 122        list_del(&engctx->head);
 123        spin_unlock_irqrestore(&engine->lock, save);
 124
 125        if (client->vm)
 126                atomic_dec(&client->vm->engref[nv_engidx(engobj)]);
 127
 128        if (engctx->base.size)
 129                nouveau_gpuobj_destroy(&engctx->base);
 130        else
 131                nouveau_object_destroy(&engctx->base.base);
 132}
 133
 134int
 135nouveau_engctx_init(struct nouveau_engctx *engctx)
 136{
 137        struct nouveau_object *object = nv_object(engctx);
 138        struct nouveau_subdev *subdev = nv_subdev(object->engine);
 139        struct nouveau_object *parent;
 140        struct nouveau_subdev *pardev;
 141        int ret;
 142
 143        ret = nouveau_gpuobj_init(&engctx->base);
 144        if (ret)
 145                return ret;
 146
 147        parent = nv_pclass(object->parent, NV_PARENT_CLASS);
 148        pardev = nv_subdev(parent->engine);
 149        if (nv_parent(parent)->context_attach) {
 150                mutex_lock(&pardev->mutex);
 151                ret = nv_parent(parent)->context_attach(parent, object);
 152                mutex_unlock(&pardev->mutex);
 153        }
 154
 155        if (ret) {
 156                nv_error(parent, "failed to attach %s context, %d\n",
 157                         subdev->name, ret);
 158                return ret;
 159        }
 160
 161        nv_debug(parent, "attached %s context\n", subdev->name);
 162        return 0;
 163}
 164
 165int
 166nouveau_engctx_fini(struct nouveau_engctx *engctx, bool suspend)
 167{
 168        struct nouveau_object *object = nv_object(engctx);
 169        struct nouveau_subdev *subdev = nv_subdev(object->engine);
 170        struct nouveau_object *parent;
 171        struct nouveau_subdev *pardev;
 172        int ret = 0;
 173
 174        parent = nv_pclass(object->parent, NV_PARENT_CLASS);
 175        pardev = nv_subdev(parent->engine);
 176        if (nv_parent(parent)->context_detach) {
 177                mutex_lock(&pardev->mutex);
 178                ret = nv_parent(parent)->context_detach(parent, suspend, object);
 179                mutex_unlock(&pardev->mutex);
 180        }
 181
 182        if (ret) {
 183                nv_error(parent, "failed to detach %s context, %d\n",
 184                         subdev->name, ret);
 185                return ret;
 186        }
 187
 188        nv_debug(parent, "detached %s context\n", subdev->name);
 189        return nouveau_gpuobj_fini(&engctx->base, suspend);
 190}
 191
 192int
 193_nouveau_engctx_ctor(struct nouveau_object *parent,
 194                     struct nouveau_object *engine,
 195                     struct nouveau_oclass *oclass, void *data, u32 size,
 196                     struct nouveau_object **pobject)
 197{
 198        struct nouveau_engctx *engctx;
 199        int ret;
 200
 201        ret = nouveau_engctx_create(parent, engine, oclass, NULL, 256, 256,
 202                                    NVOBJ_FLAG_ZERO_ALLOC, &engctx);
 203        *pobject = nv_object(engctx);
 204        return ret;
 205}
 206
 207void
 208_nouveau_engctx_dtor(struct nouveau_object *object)
 209{
 210        nouveau_engctx_destroy(nv_engctx(object));
 211}
 212
 213int
 214_nouveau_engctx_init(struct nouveau_object *object)
 215{
 216        return nouveau_engctx_init(nv_engctx(object));
 217}
 218
 219
 220int
 221_nouveau_engctx_fini(struct nouveau_object *object, bool suspend)
 222{
 223        return nouveau_engctx_fini(nv_engctx(object), suspend);
 224}
 225
 226struct nouveau_object *
 227nouveau_engctx_get(struct nouveau_engine *engine, u64 addr)
 228{
 229        struct nouveau_engctx *engctx;
 230        unsigned long flags;
 231
 232        spin_lock_irqsave(&engine->lock, flags);
 233        list_for_each_entry(engctx, &engine->contexts, head) {
 234                if (engctx->addr == addr) {
 235                        engctx->save = flags;
 236                        return nv_object(engctx);
 237                }
 238        }
 239        spin_unlock_irqrestore(&engine->lock, flags);
 240        return NULL;
 241}
 242
 243void
 244nouveau_engctx_put(struct nouveau_object *object)
 245{
 246        if (object) {
 247                struct nouveau_engine *engine = nv_engine(object->engine);
 248                struct nouveau_engctx *engctx = nv_engctx(object);
 249                spin_unlock_irqrestore(&engine->lock, engctx->save);
 250        }
 251}
 252