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 #include <core/object.h> 25 #include <core/engine.h> 26 27 #ifdef NVKM_OBJECT_MAGIC 28 static struct list_head _objlist = LIST_HEAD_INIT(_objlist); 29 static DEFINE_SPINLOCK(_objlist_lock); 30 #endif 31 32 int 33 nvkm_object_create_(struct nvkm_object *parent, struct nvkm_object *engine, 34 struct nvkm_oclass *oclass, u32 pclass, 35 int size, void **pobject) 36 { 37 struct nvkm_object *object; 38 39 object = *pobject = kzalloc(size, GFP_KERNEL); 40 if (!object) 41 return -ENOMEM; 42 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); 49 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); 55 #endif 56 return 0; 57 } 58 59 int 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) 63 { 64 if (size != 0) 65 return -ENOSYS; 66 return nvkm_object_create(parent, engine, oclass, 0, pobject); 67 } 68 69 void 70 nvkm_object_destroy(struct nvkm_object *object) 71 { 72 #ifdef NVKM_OBJECT_MAGIC 73 spin_lock(&_objlist_lock); 74 list_del(&object->list); 75 spin_unlock(&_objlist_lock); 76 #endif 77 nvkm_object_ref(NULL, (struct nvkm_object **)&object->engine); 78 nvkm_object_ref(NULL, &object->parent); 79 kfree(object); 80 } 81 82 int 83 nvkm_object_init(struct nvkm_object *object) 84 { 85 return 0; 86 } 87 88 int 89 nvkm_object_fini(struct nvkm_object *object, bool suspend) 90 { 91 return 0; 92 } 93 94 struct nvkm_ofuncs 95 nvkm_object_ofuncs = { 96 .ctor = _nvkm_object_ctor, 97 .dtor = nvkm_object_destroy, 98 .init = nvkm_object_init, 99 .fini = nvkm_object_fini, 100 }; 101 102 int 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) 106 { 107 struct nvkm_ofuncs *ofuncs = oclass->ofuncs; 108 struct nvkm_object *object = NULL; 109 int ret; 110 111 ret = ofuncs->ctor(parent, engine, oclass, data, size, &object); 112 *pobject = object; 113 if (ret < 0) { 114 if (ret != -ENODEV) { 115 nv_error(parent, "failed to create 0x%08x, %d\n", 116 oclass->handle, ret); 117 } 118 119 if (object) { 120 ofuncs->dtor(object); 121 *pobject = NULL; 122 } 123 124 return ret; 125 } 126 127 if (ret == 0) { 128 nv_trace(object, "created\n"); 129 atomic_set(&object->refcount, 1); 130 } 131 132 return 0; 133 } 134 135 static void 136 nvkm_object_dtor(struct nvkm_object *object) 137 { 138 nv_trace(object, "destroying\n"); 139 nv_ofuncs(object)->dtor(object); 140 } 141 142 void 143 nvkm_object_ref(struct nvkm_object *obj, struct nvkm_object **ref) 144 { 145 if (obj) { 146 atomic_inc(&obj->refcount); 147 nv_trace(obj, "inc() == %d\n", atomic_read(&obj->refcount)); 148 } 149 150 if (*ref) { 151 int dead = atomic_dec_and_test(&(*ref)->refcount); 152 nv_trace(*ref, "dec() == %d\n", atomic_read(&(*ref)->refcount)); 153 if (dead) 154 nvkm_object_dtor(*ref); 155 } 156 157 *ref = obj; 158 } 159 160 int 161 nvkm_object_inc(struct nvkm_object *object) 162 { 163 int ref = atomic_add_return(1, &object->usecount); 164 int ret; 165 166 nv_trace(object, "use(+1) == %d\n", atomic_read(&object->usecount)); 167 if (ref != 1) 168 return 0; 169 170 nv_trace(object, "initialising...\n"); 171 if (object->parent) { 172 ret = nvkm_object_inc(object->parent); 173 if (ret) { 174 nv_error(object, "parent failed, %d\n", ret); 175 goto fail_parent; 176 } 177 } 178 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); 183 if (ret) { 184 nv_error(object, "engine failed, %d\n", ret); 185 goto fail_engine; 186 } 187 } 188 189 ret = nv_ofuncs(object)->init(object); 190 atomic_set(&object->usecount, 1); 191 if (ret) { 192 nv_error(object, "init failed, %d\n", ret); 193 goto fail_self; 194 } 195 196 nv_trace(object, "initialised\n"); 197 return 0; 198 199 fail_self: 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); 204 } 205 fail_engine: 206 if (object->parent) 207 nvkm_object_dec(object->parent, false); 208 fail_parent: 209 atomic_dec(&object->usecount); 210 return ret; 211 } 212 213 static int 214 nvkm_object_decf(struct nvkm_object *object) 215 { 216 int ret; 217 218 nv_trace(object, "stopping...\n"); 219 220 ret = nv_ofuncs(object)->fini(object, false); 221 atomic_set(&object->usecount, 0); 222 if (ret) 223 nv_warn(object, "failed fini, %d\n", ret); 224 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); 229 } 230 231 if (object->parent) 232 nvkm_object_dec(object->parent, false); 233 234 nv_trace(object, "stopped\n"); 235 return 0; 236 } 237 238 static int 239 nvkm_object_decs(struct nvkm_object *object) 240 { 241 int ret, rret; 242 243 nv_trace(object, "suspending...\n"); 244 245 ret = nv_ofuncs(object)->fini(object, true); 246 atomic_set(&object->usecount, 0); 247 if (ret) { 248 nv_error(object, "failed suspend, %d\n", ret); 249 return ret; 250 } 251 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); 256 if (ret) { 257 nv_warn(object, "engine failed suspend, %d\n", ret); 258 goto fail_engine; 259 } 260 } 261 262 if (object->parent) { 263 ret = nvkm_object_dec(object->parent, true); 264 if (ret) { 265 nv_warn(object, "parent failed suspend, %d\n", ret); 266 goto fail_parent; 267 } 268 } 269 270 nv_trace(object, "suspended\n"); 271 return 0; 272 273 fail_parent: 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); 278 if (rret) 279 nv_fatal(object, "engine failed to reinit, %d\n", rret); 280 } 281 282 fail_engine: 283 rret = nv_ofuncs(object)->init(object); 284 if (rret) 285 nv_fatal(object, "failed to reinit, %d\n", rret); 286 287 return ret; 288 } 289 290 int 291 nvkm_object_dec(struct nvkm_object *object, bool suspend) 292 { 293 int ref = atomic_add_return(-1, &object->usecount); 294 int ret; 295 296 nv_trace(object, "use(-1) == %d\n", atomic_read(&object->usecount)); 297 298 if (ref == 0) { 299 if (suspend) 300 ret = nvkm_object_decs(object); 301 else 302 ret = nvkm_object_decf(object); 303 304 if (ret) { 305 atomic_inc(&object->usecount); 306 return ret; 307 } 308 } 309 310 return 0; 311 } 312 313 void 314 nvkm_object_debug(void) 315 { 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)); 327 } 328 } 329 #endif 330 } 331