drivers/gpu/drm/nouveau/core/core/object.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/parent.h>
  27 #include <core/namedb.h>
  28 #include <core/handle.h>
  29 #include <core/engine.h>
  30
  31 #ifdef NOUVEAU_OBJECT_MAGIC
  32 static struct list_head _objlist = LIST_HEAD_INIT(_objlist);
  33 static DEFINE_SPINLOCK(_objlist_lock);
  34 #endif
  35
  36 int
  37 nouveau_object_create_(struct nouveau_object *parent,
  38                        struct nouveau_object *engine,
  39                        struct nouveau_oclass *oclass, u32 pclass,
  40                        int size, void **pobject)
  41 {
  42         struct nouveau_object *object;
  43
  44         object = *pobject = kzalloc(size, GFP_KERNEL);
  45         if (!object)
  46                 return -ENOMEM;
  47
  48         nouveau_object_ref(parent, &object->parent);
  49         nouveau_object_ref(engine, &object->engine);
  50         object->oclass = oclass;
  51         object->oclass->handle |= pclass;
  52         atomic_set(&object->refcount, 1);
  53         atomic_set(&object->usecount, 0);
  54
  55 #ifdef NOUVEAU_OBJECT_MAGIC
  56         object->_magic = NOUVEAU_OBJECT_MAGIC;
  57         spin_lock(&_objlist_lock);
  58         list_add(&object->list, &_objlist);
  59         spin_unlock(&_objlist_lock);
  60 #endif
  61         return 0;
  62 }
  63
  64 static int
  65 _nouveau_object_ctor(struct nouveau_object *parent,
  66                      struct nouveau_object *engine,
  67                      struct nouveau_oclass *oclass, void *data, u32 size,
  68                      struct nouveau_object **pobject)
  69 {
  70         struct nouveau_object *object;
  71         int ret;
  72
  73         ret = nouveau_object_create(parent, engine, oclass, 0, &object);
  74         *pobject = nv_object(object);
  75         if (ret)
  76                 return ret;
  77
  78         return 0;
  79 }
  80
  81 void
  82 nouveau_object_destroy(struct nouveau_object *object)
  83 {
  84 #ifdef NOUVEAU_OBJECT_MAGIC
  85         spin_lock(&_objlist_lock);
  86         list_del(&object->list);
  87         spin_unlock(&_objlist_lock);
  88 #endif
  89         nouveau_object_ref(NULL, &object->engine);
  90         nouveau_object_ref(NULL, &object->parent);
  91         kfree(object);
  92 }
  93
  94 static void
  95 _nouveau_object_dtor(struct nouveau_object *object)
  96 {
  97         nouveau_object_destroy(object);
  98 }
  99
 100 int
 101 nouveau_object_init(struct nouveau_object *object)
 102 {
 103         return 0;
 104 }
 105
 106 static int
 107 _nouveau_object_init(struct nouveau_object *object)
 108 {
 109         return nouveau_object_init(object);
 110 }
 111
 112 int
 113 nouveau_object_fini(struct nouveau_object *object, bool suspend)
 114 {
 115         return 0;
 116 }
 117
 118 static int
 119 _nouveau_object_fini(struct nouveau_object *object, bool suspend)
 120 {
 121         return nouveau_object_fini(object, suspend);
 122 }
 123
 124 struct nouveau_ofuncs
 125 nouveau_object_ofuncs = {
 126         .ctor = _nouveau_object_ctor,
 127         .dtor = _nouveau_object_dtor,
 128         .init = _nouveau_object_init,
 129         .fini = _nouveau_object_fini,
 130 };
 131
 132 int
 133 nouveau_object_ctor(struct nouveau_object *parent,
 134                     struct nouveau_object *engine,
 135                     struct nouveau_oclass *oclass, void *data, u32 size,
 136                     struct nouveau_object **pobject)
 137 {
 138         struct nouveau_ofuncs *ofuncs = oclass->ofuncs;
 139         int ret;
 140
 141         *pobject = NULL;
 142
 143         ret = ofuncs->ctor(parent, engine, oclass, data, size, pobject);
 144         if (ret < 0) {
 145                 if (ret != -ENODEV) {
 146                         nv_error(parent, "failed to create 0x%08x, %d\n",
 147                                  oclass->handle, ret);
 148                 }
 149
 150                 if (*pobject) {
 151                         ofuncs->dtor(*pobject);
 152                         *pobject = NULL;
 153                 }
 154
 155                 return ret;
 156         }
 157
 158         nv_debug(*pobject, "created\n");
 159         return 0;
 160 }
 161
 162 static void
 163 nouveau_object_dtor(struct nouveau_object *object)
 164 {
 165         nv_debug(object, "destroying\n");
 166         nv_ofuncs(object)->dtor(object);
 167 }
 168
 169 void
 170 nouveau_object_ref(struct nouveau_object *obj, struct nouveau_object **ref)
 171 {
 172         if (obj) {
 173                 atomic_inc(&obj->refcount);
 174                 nv_trace(obj, "inc() == %d\n", atomic_read(&obj->refcount));
 175         }
 176
 177         if (*ref) {
 178                 int dead = atomic_dec_and_test(&(*ref)->refcount);
 179                 nv_trace(*ref, "dec() == %d\n", atomic_read(&(*ref)->refcount));
 180                 if (dead)
 181                         nouveau_object_dtor(*ref);
 182         }
 183
 184         *ref = obj;
 185 }
 186
 187 int
 188 nouveau_object_new(struct nouveau_object *client, u32 _parent, u32 _handle,
 189                    u16 _oclass, void *data, u32 size,
 190                    struct nouveau_object **pobject)
 191 {
 192         struct nouveau_object *parent = NULL;
 193         struct nouveau_object *engctx = NULL;
 194         struct nouveau_object *object = NULL;
 195         struct nouveau_object *engine;
 196         struct nouveau_oclass *oclass;
 197         struct nouveau_handle *handle;
 198         int ret;
 199
 200         /* lookup parent object and ensure it *is* a parent */
 201         parent = nouveau_handle_ref(client, _parent);
 202         if (!parent) {
 203                 nv_error(client, "parent 0x%08x not found\n", _parent);
 204                 return -ENOENT;
 205         }
 206
 207         if (!nv_iclass(parent, NV_PARENT_CLASS)) {
 208                 nv_error(parent, "cannot have children\n");
 209                 ret = -EINVAL;
 210                 goto fail_class;
 211         }
 212
 213         /* check that parent supports the requested subclass */
 214         ret = nouveau_parent_sclass(parent, _oclass, &engine, &oclass);
 215         if (ret) {
 216                 nv_debug(parent, "illegal class 0x%04x\n", _oclass);
 217                 goto fail_class;
 218         }
 219
 220         /* make sure engine init has been completed *before* any objects
 221          * it controls are created - the constructors may depend on
 222          * state calculated at init (ie. default context construction)
 223          */
 224         if (engine) {
 225                 ret = nouveau_object_inc(engine);
 226                 if (ret)
 227                         goto fail_class;
 228         }
 229
 230         /* if engine requires it, create a context object to insert
 231          * between the parent and its children (eg. PGRAPH context)
 232          */
 233         if (engine && nv_engine(engine)->cclass) {
 234                 ret = nouveau_object_ctor(parent, engine,
 235                                           nv_engine(engine)->cclass,
 236                                           data, size, &engctx);
 237                 if (ret)
 238                         goto fail_engctx;
 239         } else {
 240                 nouveau_object_ref(parent, &engctx);
 241         }
 242
 243         /* finally, create new object and bind it to its handle */
 244         ret = nouveau_object_ctor(engctx, engine, oclass, data, size, &object);
 245         *pobject = object;
 246         if (ret)
 247                 goto fail_ctor;
 248
 249         ret = nouveau_object_inc(object);
 250         if (ret)
 251                 goto fail_init;
 252
 253         ret = nouveau_handle_create(parent, _parent, _handle, object, &handle);
 254         if (ret)
 255                 goto fail_handle;
 256
 257         ret = nouveau_handle_init(handle);
 258         if (ret)
 259                 nouveau_handle_destroy(handle);
 260
 261 fail_handle:
 262         nouveau_object_dec(object, false);
 263 fail_init:
 264         nouveau_object_ref(NULL, &object);
 265 fail_ctor:
 266         nouveau_object_ref(NULL, &engctx);
 267 fail_engctx:
 268         if (engine)
 269                 nouveau_object_dec(engine, false);
 270 fail_class:
 271         nouveau_object_ref(NULL, &parent);
 272         return ret;
 273 }
 274
 275 int
 276 nouveau_object_del(struct nouveau_object *client, u32 _parent, u32 _handle)
 277 {
 278         struct nouveau_object *parent = NULL;
 279         struct nouveau_object *namedb = NULL;
 280         struct nouveau_handle *handle = NULL;
 281         int ret = -EINVAL;
 282
 283         parent = nouveau_handle_ref(client, _parent);
 284         if (!parent)
 285                 return -ENOENT;
 286
 287         namedb = nv_pclass(parent, NV_NAMEDB_CLASS);
 288         if (namedb) {
 289                 handle = nouveau_namedb_get(nv_namedb(namedb), _handle);
 290                 if (handle) {
 291                         nouveau_namedb_put(handle);
 292                         nouveau_handle_fini(handle, false);
 293                         nouveau_handle_destroy(handle);
 294                 }
 295         }
 296
 297         nouveau_object_ref(NULL, &parent);
 298         return ret;
 299 }
 300
 301 int
 302 nouveau_object_inc(struct nouveau_object *object)
 303 {
 304         int ref = atomic_add_return(1, &object->usecount);
 305         int ret;
 306
 307         nv_trace(object, "use(+1) == %d\n", atomic_read(&object->usecount));
 308         if (ref != 1)
 309                 return 0;
 310
 311         nv_trace(object, "initialising...\n");
 312         if (object->parent) {
 313                 ret = nouveau_object_inc(object->parent);
 314                 if (ret) {
 315                         nv_error(object, "parent failed, %d\n", ret);
 316                         goto fail_parent;
 317                 }
 318         }
 319
 320         if (object->engine) {
 321                 mutex_lock(&nv_subdev(object->engine)->mutex);
 322                 ret = nouveau_object_inc(object->engine);
 323                 mutex_unlock(&nv_subdev(object->engine)->mutex);
 324                 if (ret) {
 325                         nv_error(object, "engine failed, %d\n", ret);
 326                         goto fail_engine;
 327                 }
 328         }
 329
 330         ret = nv_ofuncs(object)->init(object);
 331         if (ret) {
 332                 nv_error(object, "init failed, %d\n", ret);
 333                 goto fail_self;
 334         }
 335
 336         nv_debug(object, "initialised\n");
 337         return 0;
 338
 339 fail_self:
 340         if (object->engine) {
 341                 mutex_lock(&nv_subdev(object->engine)->mutex);
 342                 nouveau_object_dec(object->engine, false);
 343                 mutex_unlock(&nv_subdev(object->engine)->mutex);
 344         }
 345 fail_engine:
 346         if (object->parent)
 347                  nouveau_object_dec(object->parent, false);
 348 fail_parent:
 349         atomic_dec(&object->usecount);
 350         return ret;
 351 }
 352
 353 static int
 354 nouveau_object_decf(struct nouveau_object *object)
 355 {
 356         int ret;
 357
 358         nv_trace(object, "stopping...\n");
 359
 360         ret = nv_ofuncs(object)->fini(object, false);
 361         if (ret)
 362                 nv_warn(object, "failed fini, %d\n", ret);
 363
 364         if (object->engine) {
 365                 mutex_lock(&nv_subdev(object->engine)->mutex);
 366                 nouveau_object_dec(object->engine, false);
 367                 mutex_unlock(&nv_subdev(object->engine)->mutex);
 368         }
 369
 370         if (object->parent)
 371                 nouveau_object_dec(object->parent, false);
 372
 373         nv_debug(object, "stopped\n");
 374         return 0;
 375 }
 376
 377 static int
 378 nouveau_object_decs(struct nouveau_object *object)
 379 {
 380         int ret, rret;
 381
 382         nv_trace(object, "suspending...\n");
 383
 384         ret = nv_ofuncs(object)->fini(object, true);
 385         if (ret) {
 386                 nv_error(object, "failed suspend, %d\n", ret);
 387                 return ret;
 388         }
 389
 390         if (object->engine) {
 391                 mutex_lock(&nv_subdev(object->engine)->mutex);
 392                 ret = nouveau_object_dec(object->engine, true);
 393                 mutex_unlock(&nv_subdev(object->engine)->mutex);
 394                 if (ret) {
 395                         nv_warn(object, "engine failed suspend, %d\n", ret);
 396                         goto fail_engine;
 397                 }
 398         }
 399
 400         if (object->parent) {
 401                 ret = nouveau_object_dec(object->parent, true);
 402                 if (ret) {
 403                         nv_warn(object, "parent failed suspend, %d\n", ret);
 404                         goto fail_parent;
 405                 }
 406         }
 407
 408         nv_debug(object, "suspended\n");
 409         return 0;
 410
 411 fail_parent:
 412         if (object->engine) {
 413                 mutex_lock(&nv_subdev(object->engine)->mutex);
 414                 rret = nouveau_object_inc(object->engine);
 415                 mutex_unlock(&nv_subdev(object->engine)->mutex);
 416                 if (rret)
 417                         nv_fatal(object, "engine failed to reinit, %d\n", rret);
 418         }
 419
 420 fail_engine:
 421         rret = nv_ofuncs(object)->init(object);
 422         if (rret)
 423                 nv_fatal(object, "failed to reinit, %d\n", rret);
 424
 425         return ret;
 426 }
 427
 428 int
 429 nouveau_object_dec(struct nouveau_object *object, bool suspend)
 430 {
 431         int ref = atomic_add_return(-1, &object->usecount);
 432         int ret;
 433
 434         nv_trace(object, "use(-1) == %d\n", atomic_read(&object->usecount));
 435
 436         if (ref == 0) {
 437                 if (suspend)
 438                         ret = nouveau_object_decs(object);
 439                 else
 440                         ret = nouveau_object_decf(object);
 441
 442                 if (ret) {
 443                         atomic_inc(&object->usecount);
 444                         return ret;
 445                 }
 446         }
 447
 448         return 0;
 449 }
 450
 451 void
 452 nouveau_object_debug(void)
 453 {
 454 #ifdef NOUVEAU_OBJECT_MAGIC
 455         struct nouveau_object *object;
 456         if (!list_empty(&_objlist)) {
 457                 nv_fatal(NULL, "*******************************************\n");
 458                 nv_fatal(NULL, "* AIIIII! object(s) still exist!!!\n");
 459                 nv_fatal(NULL, "*******************************************\n");
 460                 list_for_each_entry(object, &_objlist, list) {
 461                         nv_fatal(object, "%p/%p/%d/%d\n",
 462                                  object->parent, object->engine,
 463                                  atomic_read(&object->refcount),
 464                                  atomic_read(&object->usecount));
 465                 }
 466         }
 467 #endif
 468 }