419 lines · c
1/*2 * Copyright 2021 Red Hat Inc.3 *4 * Permission is hereby granted, free of charge, to any person obtaining a5 * copy of this software and associated documentation files (the "Software"),6 * to deal in the Software without restriction, including without limitation7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,8 * and/or sell copies of the Software, and to permit persons to whom the9 * Software is furnished to do so, subject to the following conditions:10 *11 * The above copyright notice and this permission notice shall be included in12 * all copies or substantial portions of the Software.13 *14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR18 * 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 OR20 * OTHER DEALINGS IN THE SOFTWARE.21 */22#define nvkm_uchan(p) container_of((p), struct nvkm_uchan, object)23#include "priv.h"24#include "cgrp.h"25#include "chan.h"26#include "chid.h"27#include "runl.h"28 29#include <core/gpuobj.h>30#include <core/oproxy.h>31#include <subdev/mmu.h>32#include <engine/dma.h>33 34#include <nvif/if0020.h>35 36struct nvkm_uchan {37 struct nvkm_object object;38 struct nvkm_chan *chan;39};40 41static int42nvkm_uchan_uevent(struct nvkm_object *object, void *argv, u32 argc, struct nvkm_uevent *uevent)43{44 struct nvkm_chan *chan = nvkm_uchan(object)->chan;45 struct nvkm_runl *runl = chan->cgrp->runl;46 union nvif_chan_event_args *args = argv;47 48 if (!uevent)49 return 0;50 if (argc != sizeof(args->v0) || args->v0.version != 0)51 return -ENOSYS;52 53 switch (args->v0.type) {54 case NVIF_CHAN_EVENT_V0_NON_STALL_INTR:55 return nvkm_uevent_add(uevent, &runl->fifo->nonstall.event, runl->id,56 NVKM_FIFO_NONSTALL_EVENT, NULL);57 case NVIF_CHAN_EVENT_V0_KILLED:58 return nvkm_uevent_add(uevent, &runl->chid->event, chan->id,59 NVKM_CHAN_EVENT_ERRORED, NULL);60 default:61 break;62 }63 64 return -ENOSYS;65}66 67struct nvkm_uobj {68 struct nvkm_oproxy oproxy;69 struct nvkm_chan *chan;70 struct nvkm_cctx *cctx;71 int hash;72};73 74static int75nvkm_uchan_object_fini_1(struct nvkm_oproxy *oproxy, bool suspend)76{77 struct nvkm_uobj *uobj = container_of(oproxy, typeof(*uobj), oproxy);78 struct nvkm_chan *chan = uobj->chan;79 struct nvkm_cctx *cctx = uobj->cctx;80 struct nvkm_ectx *ectx = cctx->vctx->ectx;81 82 if (!ectx->object)83 return 0;84 85 /* Unbind engine context from channel, if no longer required. */86 if (refcount_dec_and_mutex_lock(&cctx->uses, &chan->cgrp->mutex)) {87 nvkm_chan_cctx_bind(chan, ectx->engn, NULL);88 89 if (refcount_dec_and_test(&ectx->uses))90 nvkm_object_fini(ectx->object, false);91 mutex_unlock(&chan->cgrp->mutex);92 }93 94 return 0;95}96 97static int98nvkm_uchan_object_init_0(struct nvkm_oproxy *oproxy)99{100 struct nvkm_uobj *uobj = container_of(oproxy, typeof(*uobj), oproxy);101 struct nvkm_chan *chan = uobj->chan;102 struct nvkm_cctx *cctx = uobj->cctx;103 struct nvkm_ectx *ectx = cctx->vctx->ectx;104 int ret = 0;105 106 if (!ectx->object)107 return 0;108 109 /* Bind engine context to channel, if it hasn't been already. */110 if (!refcount_inc_not_zero(&cctx->uses)) {111 mutex_lock(&chan->cgrp->mutex);112 if (!refcount_inc_not_zero(&cctx->uses)) {113 if (!refcount_inc_not_zero(&ectx->uses)) {114 ret = nvkm_object_init(ectx->object);115 if (ret == 0)116 refcount_set(&ectx->uses, 1);117 }118 119 if (ret == 0) {120 nvkm_chan_cctx_bind(chan, ectx->engn, cctx);121 refcount_set(&cctx->uses, 1);122 }123 }124 mutex_unlock(&chan->cgrp->mutex);125 }126 127 return ret;128}129 130static void131nvkm_uchan_object_dtor(struct nvkm_oproxy *oproxy)132{133 struct nvkm_uobj *uobj = container_of(oproxy, typeof(*uobj), oproxy);134 struct nvkm_engn *engn;135 136 if (!uobj->cctx)137 return;138 139 engn = uobj->cctx->vctx->ectx->engn;140 if (engn->func->ramht_del)141 engn->func->ramht_del(uobj->chan, uobj->hash);142 143 nvkm_chan_cctx_put(uobj->chan, &uobj->cctx);144}145 146static const struct nvkm_oproxy_func147nvkm_uchan_object = {148 .dtor[1] = nvkm_uchan_object_dtor,149 .init[0] = nvkm_uchan_object_init_0,150 .fini[1] = nvkm_uchan_object_fini_1,151};152 153static int154nvkm_uchan_object_new(const struct nvkm_oclass *oclass, void *argv, u32 argc,155 struct nvkm_object **pobject)156{157 struct nvkm_chan *chan = nvkm_uchan(oclass->parent)->chan;158 struct nvkm_cgrp *cgrp = chan->cgrp;159 struct nvkm_engn *engn;160 struct nvkm_uobj *uobj;161 int ret;162 163 /* Lookup host engine state for target engine. */164 engn = nvkm_runl_find_engn(engn, cgrp->runl, engn->engine == oclass->engine);165 if (WARN_ON(!engn))166 return -EINVAL;167 168 /* Allocate SW object. */169 if (!(uobj = kzalloc(sizeof(*uobj), GFP_KERNEL)))170 return -ENOMEM;171 172 nvkm_oproxy_ctor(&nvkm_uchan_object, oclass, &uobj->oproxy);173 uobj->chan = chan;174 *pobject = &uobj->oproxy.base;175 176 /* Ref. channel context for target engine.*/177 ret = nvkm_chan_cctx_get(chan, engn, &uobj->cctx, oclass->client);178 if (ret)179 return ret;180 181 /* Allocate HW object. */182 ret = oclass->base.ctor(&(const struct nvkm_oclass) {183 .base = oclass->base,184 .engn = oclass->engn,185 .handle = oclass->handle,186 .object = oclass->object,187 .client = oclass->client,188 .parent = uobj->cctx->vctx->ectx->object ?: oclass->parent,189 .engine = engn->engine,190 }, argv, argc, &uobj->oproxy.object);191 if (ret)192 return ret;193 194 if (engn->func->ramht_add) {195 uobj->hash = engn->func->ramht_add(engn, uobj->oproxy.object, uobj->chan);196 if (uobj->hash < 0)197 return uobj->hash;198 }199 200 return 0;201}202 203static int204nvkm_uchan_sclass(struct nvkm_object *object, int index, struct nvkm_oclass *oclass)205{206 struct nvkm_chan *chan = nvkm_uchan(object)->chan;207 struct nvkm_engn *engn;208 int ret, runq = 0;209 210 nvkm_runl_foreach_engn(engn, chan->cgrp->runl) {211 struct nvkm_engine *engine = engn->engine;212 int c = 0;213 214 /* Each runqueue, on runlists with multiple, has its own LCE. */215 if (engn->runl->func->runqs) {216 if (engine->subdev.type == NVKM_ENGINE_CE) {217 if (chan->runq != runq++)218 continue;219 }220 }221 222 oclass->engine = engine;223 oclass->base.oclass = 0;224 225 if (engine->func->fifo.sclass) {226 ret = engine->func->fifo.sclass(oclass, index);227 if (oclass->base.oclass) {228 if (!oclass->base.ctor)229 oclass->base.ctor = nvkm_object_new;230 oclass->ctor = nvkm_uchan_object_new;231 return 0;232 }233 234 index -= ret;235 continue;236 }237 238 while (engine->func->sclass[c].oclass) {239 if (c++ == index) {240 oclass->base = engine->func->sclass[index];241 if (!oclass->base.ctor)242 oclass->base.ctor = nvkm_object_new;243 oclass->ctor = nvkm_uchan_object_new;244 return 0;245 }246 }247 248 index -= c;249 }250 251 return -EINVAL;252}253 254static int255nvkm_uchan_map(struct nvkm_object *object, void *argv, u32 argc,256 enum nvkm_object_map *type, u64 *addr, u64 *size)257{258 struct nvkm_chan *chan = nvkm_uchan(object)->chan;259 struct nvkm_device *device = chan->cgrp->runl->fifo->engine.subdev.device;260 261 if (chan->func->userd->bar < 0)262 return -ENOSYS;263 264 *type = NVKM_OBJECT_MAP_IO;265 *addr = device->func->resource_addr(device, chan->func->userd->bar) +266 chan->func->userd->base + chan->userd.base;267 *size = chan->func->userd->size;268 return 0;269}270 271static int272nvkm_uchan_fini(struct nvkm_object *object, bool suspend)273{274 struct nvkm_chan *chan = nvkm_uchan(object)->chan;275 276 nvkm_chan_block(chan);277 nvkm_chan_remove(chan, true);278 279 if (chan->func->unbind)280 chan->func->unbind(chan);281 282 return 0;283}284 285static int286nvkm_uchan_init(struct nvkm_object *object)287{288 struct nvkm_chan *chan = nvkm_uchan(object)->chan;289 290 if (atomic_read(&chan->errored))291 return 0;292 293 if (chan->func->bind)294 chan->func->bind(chan);295 296 nvkm_chan_allow(chan);297 nvkm_chan_insert(chan);298 return 0;299}300 301static void *302nvkm_uchan_dtor(struct nvkm_object *object)303{304 struct nvkm_uchan *uchan = nvkm_uchan(object);305 306 nvkm_chan_del(&uchan->chan);307 return uchan;308}309 310static const struct nvkm_object_func311nvkm_uchan = {312 .dtor = nvkm_uchan_dtor,313 .init = nvkm_uchan_init,314 .fini = nvkm_uchan_fini,315 .map = nvkm_uchan_map,316 .sclass = nvkm_uchan_sclass,317 .uevent = nvkm_uchan_uevent,318};319 320struct nvkm_chan *321nvkm_uchan_chan(struct nvkm_object *object)322{323 if (WARN_ON(object->func != &nvkm_uchan))324 return NULL;325 326 return nvkm_uchan(object)->chan;327}328 329int330nvkm_uchan_new(struct nvkm_fifo *fifo, struct nvkm_cgrp *cgrp, const struct nvkm_oclass *oclass,331 void *argv, u32 argc, struct nvkm_object **pobject)332{333 union nvif_chan_args *args = argv;334 struct nvkm_runl *runl;335 struct nvkm_vmm *vmm = NULL;336 struct nvkm_dmaobj *ctxdma = NULL;337 struct nvkm_memory *userd = NULL;338 struct nvkm_uchan *uchan;339 struct nvkm_chan *chan;340 int ret;341 342 if (argc < sizeof(args->v0) || args->v0.version != 0)343 return -ENOSYS;344 argc -= sizeof(args->v0);345 346 if (args->v0.namelen != argc)347 return -EINVAL;348 349 /* Lookup objects referenced in args. */350 runl = nvkm_runl_get(fifo, args->v0.runlist, 0);351 if (!runl)352 return -EINVAL;353 354 if (args->v0.vmm) {355 vmm = nvkm_uvmm_search(oclass->client, args->v0.vmm);356 if (IS_ERR(vmm))357 return PTR_ERR(vmm);358 }359 360 if (args->v0.ctxdma) {361 ctxdma = nvkm_dmaobj_search(oclass->client, args->v0.ctxdma);362 if (IS_ERR(ctxdma)) {363 ret = PTR_ERR(ctxdma);364 goto done;365 }366 }367 368 if (args->v0.huserd) {369 userd = nvkm_umem_search(oclass->client, args->v0.huserd);370 if (IS_ERR(userd)) {371 ret = PTR_ERR(userd);372 userd = NULL;373 goto done;374 }375 }376 377 /* Allocate channel. */378 if (!(uchan = kzalloc(sizeof(*uchan), GFP_KERNEL))) {379 ret = -ENOMEM;380 goto done;381 }382 383 nvkm_object_ctor(&nvkm_uchan, oclass, &uchan->object);384 *pobject = &uchan->object;385 386 ret = nvkm_chan_new_(fifo->func->chan.func, runl, args->v0.runq, cgrp, args->v0.name,387 args->v0.priv != 0, args->v0.devm, vmm, ctxdma, args->v0.offset,388 args->v0.length, userd, args->v0.ouserd, &uchan->chan);389 if (ret)390 goto done;391 392 chan = uchan->chan;393 394 /* Return channel info to caller. */395 if (chan->func->doorbell_handle)396 args->v0.token = chan->func->doorbell_handle(chan);397 else398 args->v0.token = ~0;399 400 args->v0.chid = chan->id;401 402 switch (nvkm_memory_target(chan->inst->memory)) {403 case NVKM_MEM_TARGET_INST: args->v0.aper = NVIF_CHAN_V0_INST_APER_INST; break;404 case NVKM_MEM_TARGET_VRAM: args->v0.aper = NVIF_CHAN_V0_INST_APER_VRAM; break;405 case NVKM_MEM_TARGET_HOST: args->v0.aper = NVIF_CHAN_V0_INST_APER_HOST; break;406 case NVKM_MEM_TARGET_NCOH: args->v0.aper = NVIF_CHAN_V0_INST_APER_NCOH; break;407 default:408 WARN_ON(1);409 ret = -EFAULT;410 break;411 }412 413 args->v0.inst = nvkm_memory_addr(chan->inst->memory);414done:415 nvkm_memory_unref(&userd);416 nvkm_vmm_unref(&vmm);417 return ret;418}419