1 /* 2 * Copyright 2021 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 #include "chan.h" 23 24 #include <core/oproxy.h> 25 #include <core/ramht.h> 26 27 #include <nvif/if0014.h> 28 29 static int 30 nvkm_disp_chan_rd32(struct nvkm_object *object, u64 addr, u32 *data) 31 { 32 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 33 struct nvkm_device *device = chan->disp->engine.subdev.device; 34 u64 size, base = chan->func->user(chan, &size); 35 36 *data = nvkm_rd32(device, base + addr); 37 return 0; 38 } 39 40 static int 41 nvkm_disp_chan_wr32(struct nvkm_object *object, u64 addr, u32 data) 42 { 43 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 44 struct nvkm_device *device = chan->disp->engine.subdev.device; 45 u64 size, base = chan->func->user(chan, &size); 46 47 nvkm_wr32(device, base + addr, data); 48 return 0; 49 } 50 51 static int 52 nvkm_disp_chan_ntfy(struct nvkm_object *object, u32 type, struct nvkm_event **pevent) 53 { 54 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 55 struct nvkm_disp *disp = chan->disp; 56 57 switch (type) { 58 case 0: 59 *pevent = &disp->uevent; 60 return 0; 61 default: 62 break; 63 } 64 65 return -EINVAL; 66 } 67 68 static int 69 nvkm_disp_chan_map(struct nvkm_object *object, void *argv, u32 argc, 70 enum nvkm_object_map *type, u64 *addr, u64 *size) 71 { 72 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 73 struct nvkm_device *device = chan->disp->engine.subdev.device; 74 const u64 base = device->func->resource_addr(device, 0); 75 76 *type = NVKM_OBJECT_MAP_IO; 77 *addr = base + chan->func->user(chan, size); 78 return 0; 79 } 80 81 struct nvkm_disp_chan_object { 82 struct nvkm_oproxy oproxy; 83 struct nvkm_disp *disp; 84 int hash; 85 }; 86 87 static void 88 nvkm_disp_chan_child_del_(struct nvkm_oproxy *base) 89 { 90 struct nvkm_disp_chan_object *object = container_of(base, typeof(*object), oproxy); 91 92 nvkm_ramht_remove(object->disp->ramht, object->hash); 93 } 94 95 static const struct nvkm_oproxy_func 96 nvkm_disp_chan_child_func_ = { 97 .dtor[0] = nvkm_disp_chan_child_del_, 98 }; 99 100 static int 101 nvkm_disp_chan_child_new(const struct nvkm_oclass *oclass, void *argv, u32 argc, 102 struct nvkm_object **pobject) 103 { 104 struct nvkm_disp_chan *chan = nvkm_disp_chan(oclass->parent); 105 struct nvkm_disp *disp = chan->disp; 106 struct nvkm_device *device = disp->engine.subdev.device; 107 const struct nvkm_device_oclass *sclass = oclass->priv; 108 struct nvkm_disp_chan_object *object; 109 int ret; 110 111 if (!(object = kzalloc(sizeof(*object), GFP_KERNEL))) 112 return -ENOMEM; 113 nvkm_oproxy_ctor(&nvkm_disp_chan_child_func_, oclass, &object->oproxy); 114 object->disp = disp; 115 *pobject = &object->oproxy.base; 116 117 ret = sclass->ctor(device, oclass, argv, argc, &object->oproxy.object); 118 if (ret) 119 return ret; 120 121 object->hash = chan->func->bind(chan, object->oproxy.object, oclass->handle); 122 if (object->hash < 0) 123 return object->hash; 124 125 return 0; 126 } 127 128 static int 129 nvkm_disp_chan_child_get(struct nvkm_object *object, int index, struct nvkm_oclass *sclass) 130 { 131 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 132 struct nvkm_device *device = chan->disp->engine.subdev.device; 133 const struct nvkm_device_oclass *oclass = NULL; 134 135 if (chan->func->bind) 136 sclass->engine = nvkm_device_engine(device, NVKM_ENGINE_DMAOBJ, 0); 137 else 138 sclass->engine = NULL; 139 140 if (sclass->engine && sclass->engine->func->base.sclass) { 141 sclass->engine->func->base.sclass(sclass, index, &oclass); 142 if (oclass) { 143 sclass->ctor = nvkm_disp_chan_child_new; 144 sclass->priv = oclass; 145 return 0; 146 } 147 } 148 149 return -EINVAL; 150 } 151 152 static int 153 nvkm_disp_chan_fini(struct nvkm_object *object, bool suspend) 154 { 155 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 156 157 chan->func->fini(chan); 158 chan->func->intr(chan, false); 159 return 0; 160 } 161 162 static int 163 nvkm_disp_chan_init(struct nvkm_object *object) 164 { 165 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 166 167 chan->func->intr(chan, true); 168 return chan->func->init(chan); 169 } 170 171 static void * 172 nvkm_disp_chan_dtor(struct nvkm_object *object) 173 { 174 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 175 struct nvkm_disp *disp = chan->disp; 176 177 spin_lock(&disp->client.lock); 178 if (disp->chan[chan->chid.user] == chan) 179 disp->chan[chan->chid.user] = NULL; 180 spin_unlock(&disp->client.lock); 181 182 nvkm_memory_unref(&chan->memory); 183 return chan; 184 } 185 186 static const struct nvkm_object_func 187 nvkm_disp_chan = { 188 .dtor = nvkm_disp_chan_dtor, 189 .init = nvkm_disp_chan_init, 190 .fini = nvkm_disp_chan_fini, 191 .rd32 = nvkm_disp_chan_rd32, 192 .wr32 = nvkm_disp_chan_wr32, 193 .ntfy = nvkm_disp_chan_ntfy, 194 .map = nvkm_disp_chan_map, 195 .sclass = nvkm_disp_chan_child_get, 196 }; 197 198 static int 199 nvkm_disp_chan_new_(struct nvkm_disp *disp, int nr, const struct nvkm_oclass *oclass, 200 void *argv, u32 argc, struct nvkm_object **pobject) 201 { 202 const struct nvkm_disp_chan_user *user = NULL; 203 struct nvkm_disp_chan *chan; 204 union nvif_disp_chan_args *args = argv; 205 int ret, i; 206 207 for (i = 0; disp->func->user[i].ctor; i++) { 208 if (disp->func->user[i].base.oclass == oclass->base.oclass) { 209 user = disp->func->user[i].chan; 210 break; 211 } 212 } 213 214 if (WARN_ON(!user)) 215 return -EINVAL; 216 217 if (argc != sizeof(args->v0) || args->v0.version != 0) 218 return -ENOSYS; 219 if (args->v0.id >= nr || !args->v0.pushbuf != !user->func->push) 220 return -EINVAL; 221 222 if (!(chan = kzalloc(sizeof(*chan), GFP_KERNEL))) 223 return -ENOMEM; 224 *pobject = &chan->object; 225 226 nvkm_object_ctor(&nvkm_disp_chan, oclass, &chan->object); 227 chan->func = user->func; 228 chan->mthd = user->mthd; 229 chan->disp = disp; 230 chan->chid.ctrl = user->ctrl + args->v0.id; 231 chan->chid.user = user->user + args->v0.id; 232 chan->head = args->v0.id; 233 234 if (chan->func->push) { 235 ret = chan->func->push(chan, args->v0.pushbuf); 236 if (ret) 237 return ret; 238 } 239 240 spin_lock(&disp->client.lock); 241 if (disp->chan[chan->chid.user]) { 242 spin_unlock(&disp->client.lock); 243 return -EBUSY; 244 } 245 disp->chan[chan->chid.user] = chan; 246 spin_unlock(&disp->client.lock); 247 return 0; 248 } 249 250 int 251 nvkm_disp_wndw_new(const struct nvkm_oclass *oclass, void *argv, u32 argc, 252 struct nvkm_object **pobject) 253 { 254 struct nvkm_disp *disp = nvkm_udisp(oclass->parent); 255 256 return nvkm_disp_chan_new_(disp, disp->wndw.nr, oclass, argv, argc, pobject); 257 } 258 259 int 260 nvkm_disp_chan_new(const struct nvkm_oclass *oclass, void *argv, u32 argc, 261 struct nvkm_object **pobject) 262 { 263 struct nvkm_disp *disp = nvkm_udisp(oclass->parent); 264 265 return nvkm_disp_chan_new_(disp, disp->head.nr, oclass, argv, argc, pobject); 266 } 267 268 int 269 nvkm_disp_core_new(const struct nvkm_oclass *oclass, void *argv, u32 argc, 270 struct nvkm_object **pobject) 271 { 272 struct nvkm_disp *disp = nvkm_udisp(oclass->parent); 273 274 return nvkm_disp_chan_new_(disp, 1, oclass, argv, argc, pobject); 275 } 276