kernel/drivers/gpu/drm/nouveau/nvkm/engine/pm/base.c

   1 /*
   2  * Copyright 2013 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 "priv.h"
  25
  26 #include <core/client.h>
  27 #include <core/option.h>
  28
  29 #include <nvif/class.h>
  30 #include <nvif/ioctl.h>
  31 #include <nvif/unpack.h>
  32
  33 static u8
  34 nvkm_pm_count_perfdom(struct nvkm_pm *pm)
  35 {
  36         struct nvkm_perfdom *dom;
  37         u8 domain_nr = 0;
  38
  39         list_for_each_entry(dom, &pm->domains, head)
  40                 domain_nr++;
  41         return domain_nr;
  42 }
  43
  44 static u16
  45 nvkm_perfdom_count_perfsig(struct nvkm_perfdom *dom)
  46 {
  47         u16 signal_nr = 0;
  48         int i;
  49
  50         if (dom) {
  51                 for (i = 0; i < dom->signal_nr; i++) {
  52                         if (dom->signal[i].name)
  53                                 signal_nr++;
  54                 }
  55         }
  56         return signal_nr;
  57 }
  58
  59 static struct nvkm_perfdom *
  60 nvkm_perfdom_find(struct nvkm_pm *pm, int di)
  61 {
  62         struct nvkm_perfdom *dom;
  63         int tmp = 0;
  64
  65         list_for_each_entry(dom, &pm->domains, head) {
  66                 if (tmp++ == di)
  67                         return dom;
  68         }
  69         return NULL;
  70 }
  71
  72 struct nvkm_perfsig *
  73 nvkm_perfsig_find(struct nvkm_pm *pm, u8 di, u8 si, struct nvkm_perfdom **pdom)
  74 {
  75         struct nvkm_perfdom *dom = *pdom;
  76
  77         if (dom == NULL) {
  78                 dom = nvkm_perfdom_find(pm, di);
  79                 if (dom == NULL)
  80                         return NULL;
  81                 *pdom = dom;
  82         }
  83
  84         if (!dom->signal[si].name)
  85                 return NULL;
  86         return &dom->signal[si];
  87 }
  88
  89 static u8
  90 nvkm_perfsig_count_perfsrc(struct nvkm_perfsig *sig)
  91 {
  92         u8 source_nr = 0, i;
  93
  94         for (i = 0; i < ARRAY_SIZE(sig->source); i++) {
  95                 if (sig->source[i])
  96                         source_nr++;
  97         }
  98         return source_nr;
  99 }
 100
 101 static struct nvkm_perfsrc *
 102 nvkm_perfsrc_find(struct nvkm_pm *pm, struct nvkm_perfsig *sig, int si)
 103 {
 104         struct nvkm_perfsrc *src;
 105         bool found = false;
 106         int tmp = 1; /* Sources ID start from 1 */
 107         u8 i;
 108
 109         for (i = 0; i < ARRAY_SIZE(sig->source) && sig->source[i]; i++) {
 110                 if (sig->source[i] == si) {
 111                         found = true;
 112                         break;
 113                 }
 114         }
 115
 116         if (found) {
 117                 list_for_each_entry(src, &pm->sources, head) {
 118                         if (tmp++ == si)
 119                                 return src;
 120                 }
 121         }
 122
 123         return NULL;
 124 }
 125
 126 static int
 127 nvkm_perfsrc_enable(struct nvkm_pm *pm, struct nvkm_perfctr *ctr)
 128 {
 129         struct nvkm_subdev *subdev = &pm->engine.subdev;
 130         struct nvkm_device *device = subdev->device;
 131         struct nvkm_perfdom *dom = NULL;
 132         struct nvkm_perfsig *sig;
 133         struct nvkm_perfsrc *src;
 134         u32 mask, value;
 135         int i, j;
 136
 137         for (i = 0; i < 4; i++) {
 138                 for (j = 0; j < 8 && ctr->source[i][j]; j++) {
 139                         sig = nvkm_perfsig_find(pm, ctr->domain,
 140                                                 ctr->signal[i], &dom);
 141                         if (!sig)
 142                                 return -EINVAL;
 143
 144                         src = nvkm_perfsrc_find(pm, sig, ctr->source[i][j]);
 145                         if (!src)
 146                                 return -EINVAL;
 147
 148                         /* set enable bit if needed */
 149                         mask = value = 0x00000000;
 150                         if (src->enable)
 151                                 mask = value = 0x80000000;
 152                         mask  |= (src->mask << src->shift);
 153                         value |= ((ctr->source[i][j] >> 32) << src->shift);
 154
 155                         /* enable the source */
 156                         nvkm_mask(device, src->addr, mask, value);
 157                         nvkm_debug(subdev,
 158                                    "enabled source %08x %08x %08x\n",
 159                                    src->addr, mask, value);
 160                 }
 161         }
 162         return 0;
 163 }
 164
 165 static int
 166 nvkm_perfsrc_disable(struct nvkm_pm *pm, struct nvkm_perfctr *ctr)
 167 {
 168         struct nvkm_subdev *subdev = &pm->engine.subdev;
 169         struct nvkm_device *device = subdev->device;
 170         struct nvkm_perfdom *dom = NULL;
 171         struct nvkm_perfsig *sig;
 172         struct nvkm_perfsrc *src;
 173         u32 mask;
 174         int i, j;
 175
 176         for (i = 0; i < 4; i++) {
 177                 for (j = 0; j < 8 && ctr->source[i][j]; j++) {
 178                         sig = nvkm_perfsig_find(pm, ctr->domain,
 179                                                 ctr->signal[i], &dom);
 180                         if (!sig)
 181                                 return -EINVAL;
 182
 183                         src = nvkm_perfsrc_find(pm, sig, ctr->source[i][j]);
 184                         if (!src)
 185                                 return -EINVAL;
 186
 187                         /* unset enable bit if needed */
 188                         mask = 0x00000000;
 189                         if (src->enable)
 190                                 mask = 0x80000000;
 191                         mask |= (src->mask << src->shift);
 192
 193                         /* disable the source */
 194                         nvkm_mask(device, src->addr, mask, 0);
 195                         nvkm_debug(subdev, "disabled source %08x %08x\n",
 196                                    src->addr, mask);
 197                 }
 198         }
 199         return 0;
 200 }
 201
 202 /*******************************************************************************
 203  * Perfdom object classes
 204  ******************************************************************************/
 205 static int
 206 nvkm_perfdom_init(struct nvkm_perfdom *dom, void *data, u32 size)
 207 {
 208         union {
 209                 struct nvif_perfdom_init none;
 210         } *args = data;
 211         struct nvkm_object *object = &dom->object;
 212         struct nvkm_pm *pm = dom->perfmon->pm;
 213         int ret, i;
 214
 215         nvif_ioctl(object, "perfdom init size %d\n", size);
 216         if (nvif_unvers(args->none)) {
 217                 nvif_ioctl(object, "perfdom init\n");
 218         } else
 219                 return ret;
 220
 221         for (i = 0; i < 4; i++) {
 222                 if (dom->ctr[i]) {
 223                         dom->func->init(pm, dom, dom->ctr[i]);
 224
 225                         /* enable sources */
 226                         nvkm_perfsrc_enable(pm, dom->ctr[i]);
 227                 }
 228         }
 229
 230         /* start next batch of counters for sampling */
 231         dom->func->next(pm, dom);
 232         return 0;
 233 }
 234
 235 static int
 236 nvkm_perfdom_sample(struct nvkm_perfdom *dom, void *data, u32 size)
 237 {
 238         union {
 239                 struct nvif_perfdom_sample none;
 240         } *args = data;
 241         struct nvkm_object *object = &dom->object;
 242         struct nvkm_pm *pm = dom->perfmon->pm;
 243         int ret;
 244
 245         nvif_ioctl(object, "perfdom sample size %d\n", size);
 246         if (nvif_unvers(args->none)) {
 247                 nvif_ioctl(object, "perfdom sample\n");
 248         } else
 249                 return ret;
 250         pm->sequence++;
 251
 252         /* sample previous batch of counters */
 253         list_for_each_entry(dom, &pm->domains, head)
 254                 dom->func->next(pm, dom);
 255
 256         return 0;
 257 }
 258
 259 static int
 260 nvkm_perfdom_read(struct nvkm_perfdom *dom, void *data, u32 size)
 261 {
 262         union {
 263                 struct nvif_perfdom_read_v0 v0;
 264         } *args = data;
 265         struct nvkm_object *object = &dom->object;
 266         struct nvkm_pm *pm = dom->perfmon->pm;
 267         int ret, i;
 268
 269         nvif_ioctl(object, "perfdom read size %d\n", size);
 270         if (nvif_unpack(args->v0, 0, 0, false)) {
 271                 nvif_ioctl(object, "perfdom read vers %d\n", args->v0.version);
 272         } else
 273                 return ret;
 274
 275         for (i = 0; i < 4; i++) {
 276                 if (dom->ctr[i])
 277                         dom->func->read(pm, dom, dom->ctr[i]);
 278         }
 279
 280         if (!dom->clk)
 281                 return -EAGAIN;
 282
 283         for (i = 0; i < 4; i++)
 284                 if (dom->ctr[i])
 285                         args->v0.ctr[i] = dom->ctr[i]->ctr;
 286         args->v0.clk = dom->clk;
 287         return 0;
 288 }
 289
 290 static int
 291 nvkm_perfdom_mthd(struct nvkm_object *object, u32 mthd, void *data, u32 size)
 292 {
 293         struct nvkm_perfdom *dom = nvkm_perfdom(object);
 294         switch (mthd) {
 295         case NVIF_PERFDOM_V0_INIT:
 296                 return nvkm_perfdom_init(dom, data, size);
 297         case NVIF_PERFDOM_V0_SAMPLE:
 298                 return nvkm_perfdom_sample(dom, data, size);
 299         case NVIF_PERFDOM_V0_READ:
 300                 return nvkm_perfdom_read(dom, data, size);
 301         default:
 302                 break;
 303         }
 304         return -EINVAL;
 305 }
 306
 307 static void *
 308 nvkm_perfdom_dtor(struct nvkm_object *object)
 309 {
 310         struct nvkm_perfdom *dom = nvkm_perfdom(object);
 311         struct nvkm_pm *pm = dom->perfmon->pm;
 312         int i;
 313
 314         for (i = 0; i < 4; i++) {
 315                 struct nvkm_perfctr *ctr = dom->ctr[i];
 316                 if (ctr) {
 317                         nvkm_perfsrc_disable(pm, ctr);
 318                         if (ctr->head.next)
 319                                 list_del(&ctr->head);
 320                 }
 321                 kfree(ctr);
 322         }
 323
 324         return dom;
 325 }
 326
 327 static int
 328 nvkm_perfctr_new(struct nvkm_perfdom *dom, int slot, u8 domain,
 329                  struct nvkm_perfsig *signal[4], u64 source[4][8],
 330                  u16 logic_op, struct nvkm_perfctr **pctr)
 331 {
 332         struct nvkm_perfctr *ctr;
 333         int i, j;
 334
 335         if (!dom)
 336                 return -EINVAL;
 337
 338         ctr = *pctr = kzalloc(sizeof(*ctr), GFP_KERNEL);
 339         if (!ctr)
 340                 return -ENOMEM;
 341
 342         ctr->domain   = domain;
 343         ctr->logic_op = logic_op;
 344         ctr->slot     = slot;
 345         for (i = 0; i < 4; i++) {
 346                 if (signal[i]) {
 347                         ctr->signal[i] = signal[i] - dom->signal;
 348                         for (j = 0; j < 8; j++)
 349                                 ctr->source[i][j] = source[i][j];
 350                 }
 351         }
 352         list_add_tail(&ctr->head, &dom->list);
 353
 354         return 0;
 355 }
 356
 357 static const struct nvkm_object_func
 358 nvkm_perfdom = {
 359         .dtor = nvkm_perfdom_dtor,
 360         .mthd = nvkm_perfdom_mthd,
 361 };
 362
 363 static int
 364 nvkm_perfdom_new_(struct nvkm_perfmon *perfmon,
 365                   const struct nvkm_oclass *oclass, void *data, u32 size,
 366                   struct nvkm_object **pobject)
 367 {
 368         union {
 369                 struct nvif_perfdom_v0 v0;
 370         } *args = data;
 371         struct nvkm_pm *pm = perfmon->pm;
 372         struct nvkm_object *parent = oclass->parent;
 373         struct nvkm_perfdom *sdom = NULL;
 374         struct nvkm_perfctr *ctr[4] = {};
 375         struct nvkm_perfdom *dom;
 376         int c, s, m;
 377         int ret;
 378
 379         nvif_ioctl(parent, "create perfdom size %d\n", size);
 380         if (nvif_unpack(args->v0, 0, 0, false)) {
 381                 nvif_ioctl(parent, "create perfdom vers %d dom %d mode %02x\n",
 382                            args->v0.version, args->v0.domain, args->v0.mode);
 383         } else
 384                 return ret;
 385
 386         for (c = 0; c < ARRAY_SIZE(args->v0.ctr); c++) {
 387                 struct nvkm_perfsig *sig[4] = {};
 388                 u64 src[4][8] = {};
 389
 390                 for (s = 0; s < ARRAY_SIZE(args->v0.ctr[c].signal); s++) {
 391                         sig[s] = nvkm_perfsig_find(pm, args->v0.domain,
 392                                                    args->v0.ctr[c].signal[s],
 393                                                    &sdom);
 394                         if (args->v0.ctr[c].signal[s] && !sig[s])
 395                                 return -EINVAL;
 396
 397                         for (m = 0; m < 8; m++) {
 398                                 src[s][m] = args->v0.ctr[c].source[s][m];
 399                                 if (src[s][m] && !nvkm_perfsrc_find(pm, sig[s],
 400                                                                     src[s][m]))
 401                                         return -EINVAL;
 402                         }
 403                 }
 404
 405                 ret = nvkm_perfctr_new(sdom, c, args->v0.domain, sig, src,
 406                                        args->v0.ctr[c].logic_op, &ctr[c]);
 407                 if (ret)
 408                         return ret;
 409         }
 410
 411         if (!sdom)
 412                 return -EINVAL;
 413
 414         if (!(dom = kzalloc(sizeof(*dom), GFP_KERNEL)))
 415                 return -ENOMEM;
 416         nvkm_object_ctor(&nvkm_perfdom, oclass, &dom->object);
 417         dom->perfmon = perfmon;
 418         *pobject = &dom->object;
 419
 420         dom->func = sdom->func;
 421         dom->addr = sdom->addr;
 422         dom->mode = args->v0.mode;
 423         for (c = 0; c < ARRAY_SIZE(ctr); c++)
 424                 dom->ctr[c] = ctr[c];
 425         return 0;
 426 }
 427
 428 /*******************************************************************************
 429  * Perfmon object classes
 430  ******************************************************************************/
 431 static int
 432 nvkm_perfmon_mthd_query_domain(struct nvkm_perfmon *perfmon,
 433                                void *data, u32 size)
 434 {
 435         union {
 436                 struct nvif_perfmon_query_domain_v0 v0;
 437         } *args = data;
 438         struct nvkm_object *object = &perfmon->object;
 439         struct nvkm_pm *pm = perfmon->pm;
 440         struct nvkm_perfdom *dom;
 441         u8 domain_nr;
 442         int di, ret;
 443
 444         nvif_ioctl(object, "perfmon query domain size %d\n", size);
 445         if (nvif_unpack(args->v0, 0, 0, false)) {
 446                 nvif_ioctl(object, "perfmon domain vers %d iter %02x\n",
 447                            args->v0.version, args->v0.iter);
 448                 di = (args->v0.iter & 0xff) - 1;
 449         } else
 450                 return ret;
 451
 452         domain_nr = nvkm_pm_count_perfdom(pm);
 453         if (di >= (int)domain_nr)
 454                 return -EINVAL;
 455
 456         if (di >= 0) {
 457                 dom = nvkm_perfdom_find(pm, di);
 458                 if (dom == NULL)
 459                         return -EINVAL;
 460
 461                 args->v0.id         = di;
 462                 args->v0.signal_nr  = nvkm_perfdom_count_perfsig(dom);
 463                 strncpy(args->v0.name, dom->name, sizeof(args->v0.name));
 464
 465                 /* Currently only global counters (PCOUNTER) are implemented
 466                  * but this will be different for local counters (MP). */
 467                 args->v0.counter_nr = 4;
 468         }
 469
 470         if (++di < domain_nr) {
 471                 args->v0.iter = ++di;
 472                 return 0;
 473         }
 474
 475         args->v0.iter = 0xff;
 476         return 0;
 477 }
 478
 479 static int
 480 nvkm_perfmon_mthd_query_signal(struct nvkm_perfmon *perfmon,
 481                                void *data, u32 size)
 482 {
 483         union {
 484                 struct nvif_perfmon_query_signal_v0 v0;
 485         } *args = data;
 486         struct nvkm_object *object = &perfmon->object;
 487         struct nvkm_pm *pm = perfmon->pm;
 488         struct nvkm_device *device = pm->engine.subdev.device;
 489         struct nvkm_perfdom *dom;
 490         struct nvkm_perfsig *sig;
 491         const bool all = nvkm_boolopt(device->cfgopt, "NvPmShowAll", false);
 492         const bool raw = nvkm_boolopt(device->cfgopt, "NvPmUnnamed", all);
 493         int ret, si;
 494
 495         nvif_ioctl(object, "perfmon query signal size %d\n", size);
 496         if (nvif_unpack(args->v0, 0, 0, false)) {
 497                 nvif_ioctl(object,
 498                            "perfmon query signal vers %d dom %d iter %04x\n",
 499                            args->v0.version, args->v0.domain, args->v0.iter);
 500                 si = (args->v0.iter & 0xffff) - 1;
 501         } else
 502                 return ret;
 503
 504         dom = nvkm_perfdom_find(pm, args->v0.domain);
 505         if (dom == NULL || si >= (int)dom->signal_nr)
 506                 return -EINVAL;
 507
 508         if (si >= 0) {
 509                 sig = &dom->signal[si];
 510                 if (raw || !sig->name) {
 511                         snprintf(args->v0.name, sizeof(args->v0.name),
 512                                  "/%s/%02x", dom->name, si);
 513                 } else {
 514                         strncpy(args->v0.name, sig->name,
 515                                 sizeof(args->v0.name));
 516                 }
 517
 518                 args->v0.signal = si;
 519                 args->v0.source_nr = nvkm_perfsig_count_perfsrc(sig);
 520         }
 521
 522         while (++si < dom->signal_nr) {
 523                 if (all || dom->signal[si].name) {
 524                         args->v0.iter = ++si;
 525                         return 0;
 526                 }
 527         }
 528
 529         args->v0.iter = 0xffff;
 530         return 0;
 531 }
 532
 533 static int
 534 nvkm_perfmon_mthd_query_source(struct nvkm_perfmon *perfmon,
 535                                void *data, u32 size)
 536 {
 537         union {
 538                 struct nvif_perfmon_query_source_v0 v0;
 539         } *args = data;
 540         struct nvkm_object *object = &perfmon->object;
 541         struct nvkm_pm *pm = perfmon->pm;
 542         struct nvkm_perfdom *dom = NULL;
 543         struct nvkm_perfsig *sig;
 544         struct nvkm_perfsrc *src;
 545         u8 source_nr = 0;
 546         int si, ret;
 547
 548         nvif_ioctl(object, "perfmon query source size %d\n", size);
 549         if (nvif_unpack(args->v0, 0, 0, false)) {
 550                 nvif_ioctl(object,
 551                            "perfmon source vers %d dom %d sig %02x iter %02x\n",
 552                            args->v0.version, args->v0.domain, args->v0.signal,
 553                            args->v0.iter);
 554                 si = (args->v0.iter & 0xff) - 1;
 555         } else
 556                 return ret;
 557
 558         sig = nvkm_perfsig_find(pm, args->v0.domain, args->v0.signal, &dom);
 559         if (!sig)
 560                 return -EINVAL;
 561
 562         source_nr = nvkm_perfsig_count_perfsrc(sig);
 563         if (si >= (int)source_nr)
 564                 return -EINVAL;
 565
 566         if (si >= 0) {
 567                 src = nvkm_perfsrc_find(pm, sig, sig->source[si]);
 568                 if (!src)
 569                         return -EINVAL;
 570
 571                 args->v0.source = sig->source[si];
 572                 args->v0.mask   = src->mask;
 573                 strncpy(args->v0.name, src->name, sizeof(args->v0.name));
 574         }
 575
 576         if (++si < source_nr) {
 577                 args->v0.iter = ++si;
 578                 return 0;
 579         }
 580
 581         args->v0.iter = 0xff;
 582         return 0;
 583 }
 584
 585 static int
 586 nvkm_perfmon_mthd(struct nvkm_object *object, u32 mthd, void *data, u32 size)
 587 {
 588         struct nvkm_perfmon *perfmon = nvkm_perfmon(object);
 589         switch (mthd) {
 590         case NVIF_PERFMON_V0_QUERY_DOMAIN:
 591                 return nvkm_perfmon_mthd_query_domain(perfmon, data, size);
 592         case NVIF_PERFMON_V0_QUERY_SIGNAL:
 593                 return nvkm_perfmon_mthd_query_signal(perfmon, data, size);
 594         case NVIF_PERFMON_V0_QUERY_SOURCE:
 595                 return nvkm_perfmon_mthd_query_source(perfmon, data, size);
 596         default:
 597                 break;
 598         }
 599         return -EINVAL;
 600 }
 601
 602 static int
 603 nvkm_perfmon_child_new(const struct nvkm_oclass *oclass, void *data, u32 size,
 604                        struct nvkm_object **pobject)
 605 {
 606         struct nvkm_perfmon *perfmon = nvkm_perfmon(oclass->parent);
 607         return nvkm_perfdom_new_(perfmon, oclass, data, size, pobject);
 608 }
 609
 610 static int
 611 nvkm_perfmon_child_get(struct nvkm_object *object, int index,
 612                        struct nvkm_oclass *oclass)
 613 {
 614         if (index == 0) {
 615                 oclass->base.oclass = NVIF_IOCTL_NEW_V0_PERFDOM;
 616                 oclass->base.minver = 0;
 617                 oclass->base.maxver = 0;
 618                 oclass->ctor = nvkm_perfmon_child_new;
 619                 return 0;
 620         }
 621         return -EINVAL;
 622 }
 623
 624 static void *
 625 nvkm_perfmon_dtor(struct nvkm_object *object)
 626 {
 627         struct nvkm_perfmon *perfmon = nvkm_perfmon(object);
 628         struct nvkm_pm *pm = perfmon->pm;
 629         mutex_lock(&pm->engine.subdev.mutex);
 630         if (pm->perfmon == &perfmon->object)
 631                 pm->perfmon = NULL;
 632         mutex_unlock(&pm->engine.subdev.mutex);
 633         return perfmon;
 634 }
 635
 636 static const struct nvkm_object_func
 637 nvkm_perfmon = {
 638         .dtor = nvkm_perfmon_dtor,
 639         .mthd = nvkm_perfmon_mthd,
 640         .sclass = nvkm_perfmon_child_get,
 641 };
 642
 643 static int
 644 nvkm_perfmon_new(struct nvkm_pm *pm, const struct nvkm_oclass *oclass,
 645                  void *data, u32 size, struct nvkm_object **pobject)
 646 {
 647         struct nvkm_perfmon *perfmon;
 648
 649         if (!(perfmon = kzalloc(sizeof(*perfmon), GFP_KERNEL)))
 650                 return -ENOMEM;
 651         nvkm_object_ctor(&nvkm_perfmon, oclass, &perfmon->object);
 652         perfmon->pm = pm;
 653         *pobject = &perfmon->object;
 654         return 0;
 655 }
 656
 657 /*******************************************************************************
 658  * PPM engine/subdev functions
 659  ******************************************************************************/
 660
 661 static int
 662 nvkm_pm_oclass_new(struct nvkm_device *device, const struct nvkm_oclass *oclass,
 663                    void *data, u32 size, struct nvkm_object **pobject)
 664 {
 665         struct nvkm_pm *pm = nvkm_pm(oclass->engine);
 666         int ret;
 667
 668         ret = nvkm_perfmon_new(pm, oclass, data, size, pobject);
 669         if (ret)
 670                 return ret;
 671
 672         mutex_lock(&pm->engine.subdev.mutex);
 673         if (pm->perfmon == NULL)
 674                 pm->perfmon = *pobject;
 675         ret = (pm->perfmon == *pobject) ? 0 : -EBUSY;
 676         mutex_unlock(&pm->engine.subdev.mutex);
 677         return ret;
 678 }
 679
 680 static const struct nvkm_device_oclass
 681 nvkm_pm_oclass = {
 682         .base.oclass = NVIF_IOCTL_NEW_V0_PERFMON,
 683         .base.minver = -1,
 684         .base.maxver = -1,
 685         .ctor = nvkm_pm_oclass_new,
 686 };
 687
 688 static int
 689 nvkm_pm_oclass_get(struct nvkm_oclass *oclass, int index,
 690                    const struct nvkm_device_oclass **class)
 691 {
 692         if (index == 0) {
 693                 oclass->base = nvkm_pm_oclass.base;
 694                 *class = &nvkm_pm_oclass;
 695                 return index;
 696         }
 697         return 1;
 698 }
 699
 700 int
 701 nvkm_perfsrc_new(struct nvkm_pm *pm, struct nvkm_perfsig *sig,
 702                  const struct nvkm_specsrc *spec)
 703 {
 704         const struct nvkm_specsrc *ssrc;
 705         const struct nvkm_specmux *smux;
 706         struct nvkm_perfsrc *src;
 707         u8 source_nr = 0;
 708
 709         if (!spec) {
 710                 /* No sources are defined for this signal. */
 711                 return 0;
 712         }
 713
 714         ssrc = spec;
 715         while (ssrc->name) {
 716                 smux = ssrc->mux;
 717                 while (smux->name) {
 718                         bool found = false;
 719                         u8 source_id = 0;
 720                         u32 len;
 721
 722                         list_for_each_entry(src, &pm->sources, head) {
 723                                 if (src->addr == ssrc->addr &&
 724                                     src->shift == smux->shift) {
 725                                         found = true;
 726                                         break;
 727                                 }
 728                                 source_id++;
 729                         }
 730
 731                         if (!found) {
 732                                 src = kzalloc(sizeof(*src), GFP_KERNEL);
 733                                 if (!src)
 734                                         return -ENOMEM;
 735
 736                                 src->addr   = ssrc->addr;
 737                                 src->mask   = smux->mask;
 738                                 src->shift  = smux->shift;
 739                                 src->enable = smux->enable;
 740
 741                                 len = strlen(ssrc->name) +
 742                                       strlen(smux->name) + 2;
 743                                 src->name = kzalloc(len, GFP_KERNEL);
 744                                 if (!src->name) {
 745                                         kfree(src);
 746                                         return -ENOMEM;
 747                                 }
 748                                 snprintf(src->name, len, "%s_%s", ssrc->name,
 749                                          smux->name);
 750
 751                                 list_add_tail(&src->head, &pm->sources);
 752                         }
 753
 754                         sig->source[source_nr++] = source_id + 1;
 755                         smux++;
 756                 }
 757                 ssrc++;
 758         }
 759
 760         return 0;
 761 }
 762
 763 int
 764 nvkm_perfdom_new(struct nvkm_pm *pm, const char *name, u32 mask,
 765                  u32 base, u32 size_unit, u32 size_domain,
 766                  const struct nvkm_specdom *spec)
 767 {
 768         const struct nvkm_specdom *sdom;
 769         const struct nvkm_specsig *ssig;
 770         struct nvkm_perfdom *dom;
 771         int ret, i;
 772
 773         for (i = 0; i == 0 || mask; i++) {
 774                 u32 addr = base + (i * size_unit);
 775                 if (i && !(mask & (1 << i)))
 776                         continue;
 777
 778                 sdom = spec;
 779                 while (sdom->signal_nr) {
 780                         dom = kzalloc(sizeof(*dom) + sdom->signal_nr *
 781                                       sizeof(*dom->signal), GFP_KERNEL);
 782                         if (!dom)
 783                                 return -ENOMEM;
 784
 785                         if (mask) {
 786                                 snprintf(dom->name, sizeof(dom->name),
 787                                          "%s/%02x/%02x", name, i,
 788                                          (int)(sdom - spec));
 789                         } else {
 790                                 snprintf(dom->name, sizeof(dom->name),
 791                                          "%s/%02x", name, (int)(sdom - spec));
 792                         }
 793
 794                         list_add_tail(&dom->head, &pm->domains);
 795                         INIT_LIST_HEAD(&dom->list);
 796                         dom->func = sdom->func;
 797                         dom->addr = addr;
 798                         dom->signal_nr = sdom->signal_nr;
 799
 800                         ssig = (sdom++)->signal;
 801                         while (ssig->name) {
 802                                 struct nvkm_perfsig *sig =
 803                                         &dom->signal[ssig->signal];
 804                                 sig->name = ssig->name;
 805                                 ret = nvkm_perfsrc_new(pm, sig, ssig->source);
 806                                 if (ret)
 807                                         return ret;
 808                                 ssig++;
 809                         }
 810
 811                         addr += size_domain;
 812                 }
 813
 814                 mask &= ~(1 << i);
 815         }
 816
 817         return 0;
 818 }
 819
 820 static int
 821 nvkm_pm_fini(struct nvkm_engine *engine, bool suspend)
 822 {
 823         struct nvkm_pm *pm = nvkm_pm(engine);
 824         if (pm->func->fini)
 825                 pm->func->fini(pm);
 826         return 0;
 827 }
 828
 829 static void *
 830 nvkm_pm_dtor(struct nvkm_engine *engine)
 831 {
 832         struct nvkm_pm *pm = nvkm_pm(engine);
 833         struct nvkm_perfdom *dom, *next_dom;
 834         struct nvkm_perfsrc *src, *next_src;
 835
 836         list_for_each_entry_safe(dom, next_dom, &pm->domains, head) {
 837                 list_del(&dom->head);
 838                 kfree(dom);
 839         }
 840
 841         list_for_each_entry_safe(src, next_src, &pm->sources, head) {
 842                 list_del(&src->head);
 843                 kfree(src->name);
 844                 kfree(src);
 845         }
 846
 847         return pm;
 848 }
 849
 850 static const struct nvkm_engine_func
 851 nvkm_pm = {
 852         .dtor = nvkm_pm_dtor,
 853         .fini = nvkm_pm_fini,
 854         .base.sclass = nvkm_pm_oclass_get,
 855 };
 856
 857 int
 858 nvkm_pm_ctor(const struct nvkm_pm_func *func, struct nvkm_device *device,
 859              int index, struct nvkm_pm *pm)
 860 {
 861         pm->func = func;
 862         INIT_LIST_HEAD(&pm->domains);
 863         INIT_LIST_HEAD(&pm->sources);
 864         return nvkm_engine_ctor(&nvkm_pm, device, index, 0, true, &pm->engine);
 865 }