drivers/gpu/drm/nouveau/nvkm/core/ioctl.c

   1 /*
   2  * Copyright 2014 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 <bskeggs@redhat.com>
  23  */
  24 #include <core/ioctl.h>
  25 #include <core/client.h>
  26 #include <core/engine.h>
  27 #include <core/handle.h>
  28 #include <core/namedb.h>
  29
  30 #include <nvif/unpack.h>
  31 #include <nvif/ioctl.h>
  32
  33 static int
  34 nvkm_ioctl_nop(struct nvkm_handle *handle, void *data, u32 size)
  35 {
  36         struct nvkm_object *object = handle->object;
  37         union {
  38                 struct nvif_ioctl_nop none;
  39         } *args = data;
  40         int ret;
  41
  42         nvif_ioctl(object, "nop size %d\n", size);
  43         if (nvif_unvers(args->none)) {
  44                 nvif_ioctl(object, "nop\n");
  45         }
  46
  47         return ret;
  48 }
  49
  50 static int
  51 nvkm_ioctl_sclass(struct nvkm_handle *handle, void *data, u32 size)
  52 {
  53         struct nvkm_object *object = handle->object;
  54         union {
  55                 struct nvif_ioctl_sclass_v0 v0;
  56         } *args = data;
  57         int ret;
  58
  59         if (!nv_iclass(object, NV_PARENT_CLASS)) {
  60                 nvif_debug(object, "cannot have children (sclass)\n");
  61                 return -ENODEV;
  62         }
  63
  64         nvif_ioctl(object, "sclass size %d\n", size);
  65         if (nvif_unpack(args->v0, 0, 0, true)) {
  66                 nvif_ioctl(object, "sclass vers %d count %d\n",
  67                            args->v0.version, args->v0.count);
  68                 if (size == args->v0.count * sizeof(args->v0.oclass[0])) {
  69                         ret = nvkm_parent_lclass(object, args->v0.oclass,
  70                                                          args->v0.count);
  71                         if (ret >= 0) {
  72                                 args->v0.count = ret;
  73                                 ret = 0;
  74                         }
  75                 } else {
  76                         ret = -EINVAL;
  77                 }
  78         }
  79
  80         return ret;
  81 }
  82
  83 static int
  84 nvkm_ioctl_new(struct nvkm_handle *handle, void *data, u32 size)
  85 {
  86         union {
  87                 struct nvif_ioctl_new_v0 v0;
  88         } *args = data;
  89         struct nvkm_client *client = nvkm_client(handle->object);
  90         struct nvkm_object *engctx = NULL;
  91         struct nvkm_object *object = NULL;
  92         struct nvkm_parent *parent;
  93         struct nvkm_object *engine;
  94         struct nvkm_oclass *oclass;
  95         u32 _handle, _oclass;
  96         int ret;
  97
  98         nvif_ioctl(handle->object, "new size %d\n", size);
  99         if (nvif_unpack(args->v0, 0, 0, true)) {
 100                 _handle = args->v0.handle;
 101                 _oclass = args->v0.oclass;
 102         } else
 103                 return ret;
 104
 105         nvif_ioctl(handle->object, "new vers %d handle %08x class %08x "
 106                                    "route %02x token %llx\n",
 107                    args->v0.version, _handle, _oclass,
 108                    args->v0.route, args->v0.token);
 109
 110         if (!nv_iclass(handle->object, NV_PARENT_CLASS)) {
 111                 nvif_debug(handle->object, "cannot have children (ctor)\n");
 112                 ret = -ENODEV;
 113                 goto fail_class;
 114         }
 115
 116         parent = nv_parent(handle->object);
 117
 118         /* check that parent supports the requested subclass */
 119         ret = nvkm_parent_sclass(&parent->object, _oclass, &engine, &oclass);
 120         if (ret) {
 121                 nvif_debug(&parent->object, "illegal class 0x%04x\n", _oclass);
 122                 goto fail_class;
 123         }
 124
 125         /* make sure engine init has been completed *before* any objects
 126          * it controls are created - the constructors may depend on
 127          * state calculated at init (ie. default context construction)
 128          */
 129         if (engine) {
 130                 ret = nvkm_object_inc(engine);
 131                 if (ret)
 132                         goto fail_class;
 133         }
 134
 135         /* if engine requires it, create a context object to insert
 136          * between the parent and its children (eg. PGRAPH context)
 137          */
 138         if (engine && nv_engine(engine)->cclass) {
 139                 ret = nvkm_object_ctor(&parent->object, engine,
 140                                        nv_engine(engine)->cclass,
 141                                        data, size, &engctx);
 142                 if (ret)
 143                         goto fail_engctx;
 144         } else {
 145                 nvkm_object_ref(&parent->object, &engctx);
 146         }
 147
 148         /* finally, create new object and bind it to its handle */
 149         ret = nvkm_object_ctor(engctx, engine, oclass, data, size, &object);
 150         client->data = object;
 151         if (ret)
 152                 goto fail_ctor;
 153
 154         ret = nvkm_object_inc(object);
 155         if (ret)
 156                 goto fail_init;
 157
 158         ret = nvkm_handle_create(&parent->object, handle->name,
 159                                  _handle, object, &handle);
 160         if (ret)
 161                 goto fail_handle;
 162
 163         ret = nvkm_handle_init(handle);
 164         handle->route = args->v0.route;
 165         handle->token = args->v0.token;
 166         if (ret)
 167                 nvkm_handle_destroy(handle);
 168
 169 fail_handle:
 170         nvkm_object_dec(object, false);
 171 fail_init:
 172         nvkm_object_ref(NULL, &object);
 173 fail_ctor:
 174         nvkm_object_ref(NULL, &engctx);
 175 fail_engctx:
 176         if (engine)
 177                 nvkm_object_dec(engine, false);
 178 fail_class:
 179         return ret;
 180 }
 181
 182 static int
 183 nvkm_ioctl_del(struct nvkm_handle *handle, void *data, u32 size)
 184 {
 185         struct nvkm_object *object = handle->object;
 186         union {
 187                 struct nvif_ioctl_del none;
 188         } *args = data;
 189         int ret;
 190
 191         nvif_ioctl(object, "delete size %d\n", size);
 192         if (nvif_unvers(args->none)) {
 193                 nvif_ioctl(object, "delete\n");
 194                 nvkm_handle_fini(handle, false);
 195                 nvkm_handle_destroy(handle);
 196         }
 197
 198         return ret;
 199 }
 200
 201 static int
 202 nvkm_ioctl_mthd(struct nvkm_handle *handle, void *data, u32 size)
 203 {
 204         struct nvkm_object *object = handle->object;
 205         struct nvkm_ofuncs *ofuncs = object->oclass->ofuncs;
 206         union {
 207                 struct nvif_ioctl_mthd_v0 v0;
 208         } *args = data;
 209         int ret;
 210
 211         nvif_ioctl(object, "mthd size %d\n", size);
 212         if (nvif_unpack(args->v0, 0, 0, true)) {
 213                 nvif_ioctl(object, "mthd vers %d mthd %02x\n",
 214                            args->v0.version, args->v0.method);
 215                 if (ret = -ENODEV, ofuncs->mthd)
 216                         ret = ofuncs->mthd(object, args->v0.method, data, size);
 217         }
 218
 219         return ret;
 220 }
 221
 222
 223 static int
 224 nvkm_ioctl_rd(struct nvkm_handle *handle, void *data, u32 size)
 225 {
 226         struct nvkm_object *object = handle->object;
 227         union {
 228                 struct nvif_ioctl_rd_v0 v0;
 229         } *args = data;
 230         union {
 231                 u8  b08;
 232                 u16 b16;
 233                 u32 b32;
 234         } v;
 235         int ret;
 236
 237         nvif_ioctl(object, "rd size %d\n", size);
 238         if (nvif_unpack(args->v0, 0, 0, false)) {
 239                 nvif_ioctl(object, "rd vers %d size %d addr %016llx\n",
 240                            args->v0.version, args->v0.size, args->v0.addr);
 241                 switch (args->v0.size) {
 242                 case 1:
 243                         ret = nvkm_object_rd08(object, args->v0.addr, &v.b08);
 244                         args->v0.data = v.b08;
 245                         break;
 246                 case 2:
 247                         ret = nvkm_object_rd16(object, args->v0.addr, &v.b16);
 248                         args->v0.data = v.b16;
 249                         break;
 250                 case 4:
 251                         ret = nvkm_object_rd32(object, args->v0.addr, &v.b32);
 252                         args->v0.data = v.b32;
 253                         break;
 254                 default:
 255                         ret = -EINVAL;
 256                         break;
 257                 }
 258         }
 259
 260         return ret;
 261 }
 262
 263 static int
 264 nvkm_ioctl_wr(struct nvkm_handle *handle, void *data, u32 size)
 265 {
 266         struct nvkm_object *object = handle->object;
 267         union {
 268                 struct nvif_ioctl_wr_v0 v0;
 269         } *args = data;
 270         int ret;
 271
 272         nvif_ioctl(object, "wr size %d\n", size);
 273         if (nvif_unpack(args->v0, 0, 0, false)) {
 274                 nvif_ioctl(object,
 275                            "wr vers %d size %d addr %016llx data %08x\n",
 276                            args->v0.version, args->v0.size, args->v0.addr,
 277                            args->v0.data);
 278         } else
 279                 return ret;
 280
 281         switch (args->v0.size) {
 282         case 1: return nvkm_object_wr08(object, args->v0.addr, args->v0.data);
 283         case 2: return nvkm_object_wr16(object, args->v0.addr, args->v0.data);
 284         case 4: return nvkm_object_wr32(object, args->v0.addr, args->v0.data);
 285         default:
 286                 break;
 287         }
 288
 289         return -EINVAL;
 290 }
 291
 292 static int
 293 nvkm_ioctl_map(struct nvkm_handle *handle, void *data, u32 size)
 294 {
 295         struct nvkm_object *object = handle->object;
 296         struct nvkm_ofuncs *ofuncs = object->oclass->ofuncs;
 297         union {
 298                 struct nvif_ioctl_map_v0 v0;
 299         } *args = data;
 300         int ret;
 301
 302         nvif_ioctl(object, "map size %d\n", size);
 303         if (nvif_unpack(args->v0, 0, 0, false)) {
 304                 nvif_ioctl(object, "map vers %d\n", args->v0.version);
 305                 if (ret = -ENODEV, ofuncs->map) {
 306                         ret = ofuncs->map(object, &args->v0.handle,
 307                                                   &args->v0.length);
 308                 }
 309         }
 310
 311         return ret;
 312 }
 313
 314 static int
 315 nvkm_ioctl_unmap(struct nvkm_handle *handle, void *data, u32 size)
 316 {
 317         struct nvkm_object *object = handle->object;
 318         union {
 319                 struct nvif_ioctl_unmap none;
 320         } *args = data;
 321         int ret;
 322
 323         nvif_ioctl(object, "unmap size %d\n", size);
 324         if (nvif_unvers(args->none)) {
 325                 nvif_ioctl(object, "unmap\n");
 326         }
 327
 328         return ret;
 329 }
 330
 331 static int
 332 nvkm_ioctl_ntfy_new(struct nvkm_handle *handle, void *data, u32 size)
 333 {
 334         struct nvkm_object *object = handle->object;
 335         struct nvkm_ofuncs *ofuncs = object->oclass->ofuncs;
 336         union {
 337                 struct nvif_ioctl_ntfy_new_v0 v0;
 338         } *args = data;
 339         struct nvkm_event *event;
 340         int ret;
 341
 342         nvif_ioctl(object, "ntfy new size %d\n", size);
 343         if (nvif_unpack(args->v0, 0, 0, true)) {
 344                 nvif_ioctl(object, "ntfy new vers %d event %02x\n",
 345                            args->v0.version, args->v0.event);
 346                 if (ret = -ENODEV, ofuncs->ntfy)
 347                         ret = ofuncs->ntfy(object, args->v0.event, &event);
 348                 if (ret == 0) {
 349                         ret = nvkm_client_notify_new(object, event, data, size);
 350                         if (ret >= 0) {
 351                                 args->v0.index = ret;
 352                                 ret = 0;
 353                         }
 354                 }
 355         }
 356
 357         return ret;
 358 }
 359
 360 static int
 361 nvkm_ioctl_ntfy_del(struct nvkm_handle *handle, void *data, u32 size)
 362 {
 363         struct nvkm_client *client = nvkm_client(handle->object);
 364         struct nvkm_object *object = handle->object;
 365         union {
 366                 struct nvif_ioctl_ntfy_del_v0 v0;
 367         } *args = data;
 368         int ret;
 369
 370         nvif_ioctl(object, "ntfy del size %d\n", size);
 371         if (nvif_unpack(args->v0, 0, 0, false)) {
 372                 nvif_ioctl(object, "ntfy del vers %d index %d\n",
 373                            args->v0.version, args->v0.index);
 374                 ret = nvkm_client_notify_del(client, args->v0.index);
 375         }
 376
 377         return ret;
 378 }
 379
 380 static int
 381 nvkm_ioctl_ntfy_get(struct nvkm_handle *handle, void *data, u32 size)
 382 {
 383         struct nvkm_client *client = nvkm_client(handle->object);
 384         struct nvkm_object *object = handle->object;
 385         union {
 386                 struct nvif_ioctl_ntfy_get_v0 v0;
 387         } *args = data;
 388         int ret;
 389
 390         nvif_ioctl(object, "ntfy get size %d\n", size);
 391         if (nvif_unpack(args->v0, 0, 0, false)) {
 392                 nvif_ioctl(object, "ntfy get vers %d index %d\n",
 393                            args->v0.version, args->v0.index);
 394                 ret = nvkm_client_notify_get(client, args->v0.index);
 395         }
 396
 397         return ret;
 398 }
 399
 400 static int
 401 nvkm_ioctl_ntfy_put(struct nvkm_handle *handle, void *data, u32 size)
 402 {
 403         struct nvkm_client *client = nvkm_client(handle->object);
 404         struct nvkm_object *object = handle->object;
 405         union {
 406                 struct nvif_ioctl_ntfy_put_v0 v0;
 407         } *args = data;
 408         int ret;
 409
 410         nvif_ioctl(object, "ntfy put size %d\n", size);
 411         if (nvif_unpack(args->v0, 0, 0, false)) {
 412                 nvif_ioctl(object, "ntfy put vers %d index %d\n",
 413                            args->v0.version, args->v0.index);
 414                 ret = nvkm_client_notify_put(client, args->v0.index);
 415         }
 416
 417         return ret;
 418 }
 419
 420 static struct {
 421         int version;
 422         int (*func)(struct nvkm_handle *, void *, u32);
 423 }
 424 nvkm_ioctl_v0[] = {
 425         { 0x00, nvkm_ioctl_nop },
 426         { 0x00, nvkm_ioctl_sclass },
 427         { 0x00, nvkm_ioctl_new },
 428         { 0x00, nvkm_ioctl_del },
 429         { 0x00, nvkm_ioctl_mthd },
 430         { 0x00, nvkm_ioctl_rd },
 431         { 0x00, nvkm_ioctl_wr },
 432         { 0x00, nvkm_ioctl_map },
 433         { 0x00, nvkm_ioctl_unmap },
 434         { 0x00, nvkm_ioctl_ntfy_new },
 435         { 0x00, nvkm_ioctl_ntfy_del },
 436         { 0x00, nvkm_ioctl_ntfy_get },
 437         { 0x00, nvkm_ioctl_ntfy_put },
 438 };
 439
 440 static int
 441 nvkm_ioctl_path(struct nvkm_handle *parent, u32 type, u32 nr, u32 *path,
 442                 void *data, u32 size, u8 owner, u8 *route, u64 *token)
 443 {
 444         struct nvkm_handle *handle = parent;
 445         struct nvkm_namedb *namedb;
 446         struct nvkm_object *object;
 447         int ret;
 448
 449         while ((object = parent->object), nr--) {
 450                 nvif_ioctl(object, "path 0x%08x\n", path[nr]);
 451                 if (!nv_iclass(object, NV_PARENT_CLASS)) {
 452                         nvif_debug(object, "cannot have children (path)\n");
 453                         return -EINVAL;
 454                 }
 455
 456                 if (!(namedb = (void *)nv_pclass(object, NV_NAMEDB_CLASS)) ||
 457                     !(handle = nvkm_namedb_get(namedb, path[nr]))) {
 458                         nvif_debug(object, "handle 0x%08x not found\n", path[nr]);
 459                         return -ENOENT;
 460                 }
 461                 nvkm_namedb_put(handle);
 462                 parent = handle;
 463         }
 464
 465         if (owner != NVIF_IOCTL_V0_OWNER_ANY && owner != handle->route) {
 466                 nvif_ioctl(object, "object route != owner\n");
 467                 return -EACCES;
 468         }
 469         *route = handle->route;
 470         *token = handle->token;
 471
 472         if (ret = -EINVAL, type < ARRAY_SIZE(nvkm_ioctl_v0)) {
 473                 if (nvkm_ioctl_v0[type].version == 0)
 474                         ret = nvkm_ioctl_v0[type].func(handle, data, size);
 475         }
 476
 477         return ret;
 478 }
 479
 480 int
 481 nvkm_ioctl(struct nvkm_client *client, bool supervisor,
 482            void *data, u32 size, void **hack)
 483 {
 484         struct nvkm_object *object = &client->namedb.parent.object;
 485         union {
 486                 struct nvif_ioctl_v0 v0;
 487         } *args = data;
 488         int ret;
 489
 490         client->super = supervisor;
 491         nvif_ioctl(object, "size %d\n", size);
 492
 493         if (nvif_unpack(args->v0, 0, 0, true)) {
 494                 nvif_ioctl(object, "vers %d type %02x path %d owner %02x\n",
 495                            args->v0.version, args->v0.type, args->v0.path_nr,
 496                            args->v0.owner);
 497                 ret = nvkm_ioctl_path(client->root, args->v0.type,
 498                                       args->v0.path_nr, args->v0.path,
 499                                       data, size, args->v0.owner,
 500                                       &args->v0.route, &args->v0.token);
 501         }
 502
 503         nvif_ioctl(object, "return %d\n", ret);
 504         if (hack) {
 505                 *hack = client->data;
 506                 client->data = NULL;
 507         }
 508
 509         client->super = false;
 510         return ret;
 511 }