2 * Copyright 2012 Red Hat Inc.
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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.
24 #include <core/object.h>
25 #include <core/engine.h>
27 #ifdef NVKM_OBJECT_MAGIC
28 static struct list_head _objlist = LIST_HEAD_INIT(_objlist);
29 static DEFINE_SPINLOCK(_objlist_lock);
33 nvkm_object_create_(struct nvkm_object *parent, struct nvkm_object *engine,
34 struct nvkm_oclass *oclass, u32 pclass,
35 int size, void **pobject)
37 struct nvkm_object *object;
39 object = *pobject = kzalloc(size, GFP_KERNEL);
43 nvkm_object_ref(parent, &object->parent);
44 nvkm_object_ref(engine, (struct nvkm_object **)&object->engine);
45 object->oclass = oclass;
46 object->oclass->handle |= pclass;
47 atomic_set(&object->refcount, 1);
48 atomic_set(&object->usecount, 0);
50 #ifdef NVKM_OBJECT_MAGIC
51 object->_magic = NVKM_OBJECT_MAGIC;
52 spin_lock(&_objlist_lock);
53 list_add(&object->list, &_objlist);
54 spin_unlock(&_objlist_lock);
60 _nvkm_object_ctor(struct nvkm_object *parent, struct nvkm_object *engine,
61 struct nvkm_oclass *oclass, void *data, u32 size,
62 struct nvkm_object **pobject)
66 return nvkm_object_create(parent, engine, oclass, 0, pobject);
70 nvkm_object_destroy(struct nvkm_object *object)
72 #ifdef NVKM_OBJECT_MAGIC
73 spin_lock(&_objlist_lock);
74 list_del(&object->list);
75 spin_unlock(&_objlist_lock);
77 nvkm_object_ref(NULL, (struct nvkm_object **)&object->engine);
78 nvkm_object_ref(NULL, &object->parent);
83 nvkm_object_init(struct nvkm_object *object)
89 nvkm_object_fini(struct nvkm_object *object, bool suspend)
95 nvkm_object_ofuncs = {
96 .ctor = _nvkm_object_ctor,
97 .dtor = nvkm_object_destroy,
98 .init = nvkm_object_init,
99 .fini = nvkm_object_fini,
103 nvkm_object_ctor(struct nvkm_object *parent, struct nvkm_object *engine,
104 struct nvkm_oclass *oclass, void *data, u32 size,
105 struct nvkm_object **pobject)
107 struct nvkm_ofuncs *ofuncs = oclass->ofuncs;
108 struct nvkm_object *object = NULL;
111 ret = ofuncs->ctor(parent, engine, oclass, data, size, &object);
114 if (ret != -ENODEV) {
115 nv_error(parent, "failed to create 0x%08x, %d\n",
116 oclass->handle, ret);
120 ofuncs->dtor(object);
128 nv_trace(object, "created\n");
129 atomic_set(&object->refcount, 1);
136 nvkm_object_dtor(struct nvkm_object *object)
138 nv_trace(object, "destroying\n");
139 nv_ofuncs(object)->dtor(object);
143 nvkm_object_ref(struct nvkm_object *obj, struct nvkm_object **ref)
146 atomic_inc(&obj->refcount);
147 nv_trace(obj, "inc() == %d\n", atomic_read(&obj->refcount));
151 int dead = atomic_dec_and_test(&(*ref)->refcount);
152 nv_trace(*ref, "dec() == %d\n", atomic_read(&(*ref)->refcount));
154 nvkm_object_dtor(*ref);
161 nvkm_object_inc(struct nvkm_object *object)
163 int ref = atomic_add_return(1, &object->usecount);
166 nv_trace(object, "use(+1) == %d\n", atomic_read(&object->usecount));
170 nv_trace(object, "initialising...\n");
171 if (object->parent) {
172 ret = nvkm_object_inc(object->parent);
174 nv_error(object, "parent failed, %d\n", ret);
179 if (object->engine) {
180 mutex_lock(&nv_subdev(object->engine)->mutex);
181 ret = nvkm_object_inc(&object->engine->subdev.object);
182 mutex_unlock(&nv_subdev(object->engine)->mutex);
184 nv_error(object, "engine failed, %d\n", ret);
189 ret = nv_ofuncs(object)->init(object);
190 atomic_set(&object->usecount, 1);
192 nv_error(object, "init failed, %d\n", ret);
196 nv_trace(object, "initialised\n");
200 if (object->engine) {
201 mutex_lock(&nv_subdev(object->engine)->mutex);
202 nvkm_object_dec(&object->engine->subdev.object, false);
203 mutex_unlock(&nv_subdev(object->engine)->mutex);
207 nvkm_object_dec(object->parent, false);
209 atomic_dec(&object->usecount);
214 nvkm_object_decf(struct nvkm_object *object)
218 nv_trace(object, "stopping...\n");
220 ret = nv_ofuncs(object)->fini(object, false);
221 atomic_set(&object->usecount, 0);
223 nv_warn(object, "failed fini, %d\n", ret);
225 if (object->engine) {
226 mutex_lock(&nv_subdev(object->engine)->mutex);
227 nvkm_object_dec(&object->engine->subdev.object, false);
228 mutex_unlock(&nv_subdev(object->engine)->mutex);
232 nvkm_object_dec(object->parent, false);
234 nv_trace(object, "stopped\n");
239 nvkm_object_decs(struct nvkm_object *object)
243 nv_trace(object, "suspending...\n");
245 ret = nv_ofuncs(object)->fini(object, true);
246 atomic_set(&object->usecount, 0);
248 nv_error(object, "failed suspend, %d\n", ret);
252 if (object->engine) {
253 mutex_lock(&nv_subdev(object->engine)->mutex);
254 ret = nvkm_object_dec(&object->engine->subdev.object, true);
255 mutex_unlock(&nv_subdev(object->engine)->mutex);
257 nv_warn(object, "engine failed suspend, %d\n", ret);
262 if (object->parent) {
263 ret = nvkm_object_dec(object->parent, true);
265 nv_warn(object, "parent failed suspend, %d\n", ret);
270 nv_trace(object, "suspended\n");
274 if (object->engine) {
275 mutex_lock(&nv_subdev(object->engine)->mutex);
276 rret = nvkm_object_inc(&object->engine->subdev.object);
277 mutex_unlock(&nv_subdev(object->engine)->mutex);
279 nv_fatal(object, "engine failed to reinit, %d\n", rret);
283 rret = nv_ofuncs(object)->init(object);
285 nv_fatal(object, "failed to reinit, %d\n", rret);
291 nvkm_object_dec(struct nvkm_object *object, bool suspend)
293 int ref = atomic_add_return(-1, &object->usecount);
296 nv_trace(object, "use(-1) == %d\n", atomic_read(&object->usecount));
300 ret = nvkm_object_decs(object);
302 ret = nvkm_object_decf(object);
305 atomic_inc(&object->usecount);
314 nvkm_object_debug(void)
316 #ifdef NVKM_OBJECT_MAGIC
317 struct nvkm_object *object;
318 if (!list_empty(&_objlist)) {
319 nv_fatal(NULL, "*******************************************\n");
320 nv_fatal(NULL, "* AIIIII! object(s) still exist!!!\n");
321 nv_fatal(NULL, "*******************************************\n");
322 list_for_each_entry(object, &_objlist, list) {
323 nv_fatal(object, "%p/%p/%d/%d\n",
324 object->parent, object->engine,
325 atomic_read(&object->refcount),
326 atomic_read(&object->usecount));