drivers/gpu/drm/nouveau/nv50_pm.c

   1 /*
   2  * Copyright 2010 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
  25 #include <drm/drmP.h>
  26 #include "nouveau_drv.h"
  27 #include "nouveau_bios.h"
  28 #include "nouveau_hw.h"
  29 #include "nouveau_pm.h"
  30 #include "nouveau_hwsq.h"
  31 #include "nv50_display.h"
  32
  33 enum clk_src {
  34         clk_src_crystal,
  35         clk_src_href,
  36         clk_src_hclk,
  37         clk_src_hclkm3,
  38         clk_src_hclkm3d2,
  39         clk_src_host,
  40         clk_src_nvclk,
  41         clk_src_sclk,
  42         clk_src_mclk,
  43         clk_src_vdec,
  44         clk_src_dom6
  45 };
  46
  47 static u32 read_clk(struct drm_device *, enum clk_src);
  48
  49 static u32
  50 read_div(struct drm_device *dev)
  51 {
  52         struct drm_nouveau_private *dev_priv = dev->dev_private;
  53
  54         switch (dev_priv->chipset) {
  55         case 0x50: /* it exists, but only has bit 31, not the dividers.. */
  56         case 0x84:
  57         case 0x86:
  58         case 0x98:
  59         case 0xa0:
  60                 return nv_rd32(dev, 0x004700);
  61         case 0x92:
  62         case 0x94:
  63         case 0x96:
  64                 return nv_rd32(dev, 0x004800);
  65         default:
  66                 return 0x00000000;
  67         }
  68 }
  69
  70 static u32
  71 read_pll_src(struct drm_device *dev, u32 base)
  72 {
  73         struct drm_nouveau_private *dev_priv = dev->dev_private;
  74         u32 coef, ref = read_clk(dev, clk_src_crystal);
  75         u32 rsel = nv_rd32(dev, 0x00e18c);
  76         int P, N, M, id;
  77
  78         switch (dev_priv->chipset) {
  79         case 0x50:
  80         case 0xa0:
  81                 switch (base) {
  82                 case 0x4020:
  83                 case 0x4028: id = !!(rsel & 0x00000004); break;
  84                 case 0x4008: id = !!(rsel & 0x00000008); break;
  85                 case 0x4030: id = 0; break;
  86                 default:
  87                         NV_ERROR(dev, "ref: bad pll 0x%06x\n", base);
  88                         return 0;
  89                 }
  90
  91                 coef = nv_rd32(dev, 0x00e81c + (id * 0x0c));
  92                 ref *=  (coef & 0x01000000) ? 2 : 4;
  93                 P    =  (coef & 0x00070000) >> 16;
  94                 N    = ((coef & 0x0000ff00) >> 8) + 1;
  95                 M    = ((coef & 0x000000ff) >> 0) + 1;
  96                 break;
  97         case 0x84:
  98         case 0x86:
  99         case 0x92:
 100                 coef = nv_rd32(dev, 0x00e81c);
 101                 P    = (coef & 0x00070000) >> 16;
 102                 N    = (coef & 0x0000ff00) >> 8;
 103                 M    = (coef & 0x000000ff) >> 0;
 104                 break;
 105         case 0x94:
 106         case 0x96:
 107         case 0x98:
 108                 rsel = nv_rd32(dev, 0x00c050);
 109                 switch (base) {
 110                 case 0x4020: rsel = (rsel & 0x00000003) >> 0; break;
 111                 case 0x4008: rsel = (rsel & 0x0000000c) >> 2; break;
 112                 case 0x4028: rsel = (rsel & 0x00001800) >> 11; break;
 113                 case 0x4030: rsel = 3; break;
 114                 default:
 115                         NV_ERROR(dev, "ref: bad pll 0x%06x\n", base);
 116                         return 0;
 117                 }
 118
 119                 switch (rsel) {
 120                 case 0: id = 1; break;
 121                 case 1: return read_clk(dev, clk_src_crystal);
 122                 case 2: return read_clk(dev, clk_src_href);
 123                 case 3: id = 0; break;
 124                 }
 125
 126                 coef =  nv_rd32(dev, 0x00e81c + (id * 0x28));
 127                 P    = (nv_rd32(dev, 0x00e824 + (id * 0x28)) >> 16) & 7;
 128                 P   += (coef & 0x00070000) >> 16;
 129                 N    = (coef & 0x0000ff00) >> 8;
 130                 M    = (coef & 0x000000ff) >> 0;
 131                 break;
 132         default:
 133                 BUG_ON(1);
 134         }
 135
 136         if (M)
 137                 return (ref * N / M) >> P;
 138         return 0;
 139 }
 140
 141 static u32
 142 read_pll_ref(struct drm_device *dev, u32 base)
 143 {
 144         u32 src, mast = nv_rd32(dev, 0x00c040);
 145
 146         switch (base) {
 147         case 0x004028:
 148                 src = !!(mast & 0x00200000);
 149                 break;
 150         case 0x004020:
 151                 src = !!(mast & 0x00400000);
 152                 break;
 153         case 0x004008:
 154                 src = !!(mast & 0x00010000);
 155                 break;
 156         case 0x004030:
 157                 src = !!(mast & 0x02000000);
 158                 break;
 159         case 0x00e810:
 160                 return read_clk(dev, clk_src_crystal);
 161         default:
 162                 NV_ERROR(dev, "bad pll 0x%06x\n", base);
 163                 return 0;
 164         }
 165
 166         if (src)
 167                 return read_clk(dev, clk_src_href);
 168         return read_pll_src(dev, base);
 169 }
 170
 171 static u32
 172 read_pll(struct drm_device *dev, u32 base)
 173 {
 174         struct drm_nouveau_private *dev_priv = dev->dev_private;
 175         u32 mast = nv_rd32(dev, 0x00c040);
 176         u32 ctrl = nv_rd32(dev, base + 0);
 177         u32 coef = nv_rd32(dev, base + 4);
 178         u32 ref = read_pll_ref(dev, base);
 179         u32 clk = 0;
 180         int N1, N2, M1, M2;
 181
 182         if (base == 0x004028 && (mast & 0x00100000)) {
 183                 /* wtf, appears to only disable post-divider on nva0 */
 184                 if (dev_priv->chipset != 0xa0)
 185                         return read_clk(dev, clk_src_dom6);
 186         }
 187
 188         N2 = (coef & 0xff000000) >> 24;
 189         M2 = (coef & 0x00ff0000) >> 16;
 190         N1 = (coef & 0x0000ff00) >> 8;
 191         M1 = (coef & 0x000000ff);
 192         if ((ctrl & 0x80000000) && M1) {
 193                 clk = ref * N1 / M1;
 194                 if ((ctrl & 0x40000100) == 0x40000000) {
 195                         if (M2)
 196                                 clk = clk * N2 / M2;
 197                         else
 198                                 clk = 0;
 199                 }
 200         }
 201
 202         return clk;
 203 }
 204
 205 static u32
 206 read_clk(struct drm_device *dev, enum clk_src src)
 207 {
 208         struct drm_nouveau_private *dev_priv = dev->dev_private;
 209         u32 mast = nv_rd32(dev, 0x00c040);
 210         u32 P = 0;
 211
 212         switch (src) {
 213         case clk_src_crystal:
 214                 return dev_priv->crystal;
 215         case clk_src_href:
 216                 return 100000; /* PCIE reference clock */
 217         case clk_src_hclk:
 218                 return read_clk(dev, clk_src_href) * 27778 / 10000;
 219         case clk_src_hclkm3:
 220                 return read_clk(dev, clk_src_hclk) * 3;
 221         case clk_src_hclkm3d2:
 222                 return read_clk(dev, clk_src_hclk) * 3 / 2;
 223         case clk_src_host:
 224                 switch (mast & 0x30000000) {
 225                 case 0x00000000: return read_clk(dev, clk_src_href);
 226                 case 0x10000000: break;
 227                 case 0x20000000: /* !0x50 */
 228                 case 0x30000000: return read_clk(dev, clk_src_hclk);
 229                 }
 230                 break;
 231         case clk_src_nvclk:
 232                 if (!(mast & 0x00100000))
 233                         P = (nv_rd32(dev, 0x004028) & 0x00070000) >> 16;
 234                 switch (mast & 0x00000003) {
 235                 case 0x00000000: return read_clk(dev, clk_src_crystal) >> P;
 236                 case 0x00000001: return read_clk(dev, clk_src_dom6);
 237                 case 0x00000002: return read_pll(dev, 0x004020) >> P;
 238                 case 0x00000003: return read_pll(dev, 0x004028) >> P;
 239                 }
 240                 break;
 241         case clk_src_sclk:
 242                 P = (nv_rd32(dev, 0x004020) & 0x00070000) >> 16;
 243                 switch (mast & 0x00000030) {
 244                 case 0x00000000:
 245                         if (mast & 0x00000080)
 246                                 return read_clk(dev, clk_src_host) >> P;
 247                         return read_clk(dev, clk_src_crystal) >> P;
 248                 case 0x00000010: break;
 249                 case 0x00000020: return read_pll(dev, 0x004028) >> P;
 250                 case 0x00000030: return read_pll(dev, 0x004020) >> P;
 251                 }
 252                 break;
 253         case clk_src_mclk:
 254                 P = (nv_rd32(dev, 0x004008) & 0x00070000) >> 16;
 255                 if (nv_rd32(dev, 0x004008) & 0x00000200) {
 256                         switch (mast & 0x0000c000) {
 257                         case 0x00000000:
 258                                 return read_clk(dev, clk_src_crystal) >> P;
 259                         case 0x00008000:
 260                         case 0x0000c000:
 261                                 return read_clk(dev, clk_src_href) >> P;
 262                         }
 263                 } else {
 264                         return read_pll(dev, 0x004008) >> P;
 265                 }
 266                 break;
 267         case clk_src_vdec:
 268                 P = (read_div(dev) & 0x00000700) >> 8;
 269                 switch (dev_priv->chipset) {
 270                 case 0x84:
 271                 case 0x86:
 272                 case 0x92:
 273                 case 0x94:
 274                 case 0x96:
 275                 case 0xa0:
 276                         switch (mast & 0x00000c00) {
 277                         case 0x00000000:
 278                                 if (dev_priv->chipset == 0xa0) /* wtf?? */
 279                                         return read_clk(dev, clk_src_nvclk) >> P;
 280                                 return read_clk(dev, clk_src_crystal) >> P;
 281                         case 0x00000400:
 282                                 return 0;
 283                         case 0x00000800:
 284                                 if (mast & 0x01000000)
 285                                         return read_pll(dev, 0x004028) >> P;
 286                                 return read_pll(dev, 0x004030) >> P;
 287                         case 0x00000c00:
 288                                 return read_clk(dev, clk_src_nvclk) >> P;
 289                         }
 290                         break;
 291                 case 0x98:
 292                         switch (mast & 0x00000c00) {
 293                         case 0x00000000:
 294                                 return read_clk(dev, clk_src_nvclk) >> P;
 295                         case 0x00000400:
 296                                 return 0;
 297                         case 0x00000800:
 298                                 return read_clk(dev, clk_src_hclkm3d2) >> P;
 299                         case 0x00000c00:
 300                                 return read_clk(dev, clk_src_mclk) >> P;
 301                         }
 302                         break;
 303                 }
 304                 break;
 305         case clk_src_dom6:
 306                 switch (dev_priv->chipset) {
 307                 case 0x50:
 308                 case 0xa0:
 309                         return read_pll(dev, 0x00e810) >> 2;
 310                 case 0x84:
 311                 case 0x86:
 312                 case 0x92:
 313                 case 0x94:
 314                 case 0x96:
 315                 case 0x98:
 316                         P = (read_div(dev) & 0x00000007) >> 0;
 317                         switch (mast & 0x0c000000) {
 318                         case 0x00000000: return read_clk(dev, clk_src_href);
 319                         case 0x04000000: break;
 320                         case 0x08000000: return read_clk(dev, clk_src_hclk);
 321                         case 0x0c000000:
 322                                 return read_clk(dev, clk_src_hclkm3) >> P;
 323                         }
 324                         break;
 325                 default:
 326                         break;
 327                 }
 328         default:
 329                 break;
 330         }
 331
 332         NV_DEBUG(dev, "unknown clock source %d 0x%08x\n", src, mast);
 333         return 0;
 334 }
 335
 336 int
 337 nv50_pm_clocks_get(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 338 {
 339         struct drm_nouveau_private *dev_priv = dev->dev_private;
 340         if (dev_priv->chipset == 0xaa ||
 341             dev_priv->chipset == 0xac)
 342                 return 0;
 343
 344         perflvl->core   = read_clk(dev, clk_src_nvclk);
 345         perflvl->shader = read_clk(dev, clk_src_sclk);
 346         perflvl->memory = read_clk(dev, clk_src_mclk);
 347         if (dev_priv->chipset != 0x50) {
 348                 perflvl->vdec = read_clk(dev, clk_src_vdec);
 349                 perflvl->dom6 = read_clk(dev, clk_src_dom6);
 350         }
 351
 352         return 0;
 353 }
 354
 355 struct nv50_pm_state {
 356         struct nouveau_pm_level *perflvl;
 357         struct hwsq_ucode eclk_hwsq;
 358         struct hwsq_ucode mclk_hwsq;
 359         u32 mscript;
 360         u32 mmast;
 361         u32 mctrl;
 362         u32 mcoef;
 363 };
 364
 365 static u32
 366 calc_pll(struct drm_device *dev, u32 reg, struct pll_lims *pll,
 367          u32 clk, int *N1, int *M1, int *log2P)
 368 {
 369         struct nouveau_pll_vals coef;
 370         int ret;
 371
 372         ret = get_pll_limits(dev, reg, pll);
 373         if (ret)
 374                 return 0;
 375
 376         pll->vco2.maxfreq = 0;
 377         pll->refclk = read_pll_ref(dev, reg);
 378         if (!pll->refclk)
 379                 return 0;
 380
 381         ret = nouveau_calc_pll_mnp(dev, pll, clk, &coef);
 382         if (ret == 0)
 383                 return 0;
 384
 385         *N1 = coef.N1;
 386         *M1 = coef.M1;
 387         *log2P = coef.log2P;
 388         return ret;
 389 }
 390
 391 static inline u32
 392 calc_div(u32 src, u32 target, int *div)
 393 {
 394         u32 clk0 = src, clk1 = src;
 395         for (*div = 0; *div <= 7; (*div)++) {
 396                 if (clk0 <= target) {
 397                         clk1 = clk0 << (*div ? 1 : 0);
 398                         break;
 399                 }
 400                 clk0 >>= 1;
 401         }
 402
 403         if (target - clk0 <= clk1 - target)
 404                 return clk0;
 405         (*div)--;
 406         return clk1;
 407 }
 408
 409 static inline u32
 410 clk_same(u32 a, u32 b)
 411 {
 412         return ((a / 1000) == (b / 1000));
 413 }
 414
 415 static void
 416 mclk_precharge(struct nouveau_mem_exec_func *exec)
 417 {
 418         struct nv50_pm_state *info = exec->priv;
 419         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 420
 421         hwsq_wr32(hwsq, 0x1002d4, 0x00000001);
 422 }
 423
 424 static void
 425 mclk_refresh(struct nouveau_mem_exec_func *exec)
 426 {
 427         struct nv50_pm_state *info = exec->priv;
 428         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 429
 430         hwsq_wr32(hwsq, 0x1002d0, 0x00000001);
 431 }
 432
 433 static void
 434 mclk_refresh_auto(struct nouveau_mem_exec_func *exec, bool enable)
 435 {
 436         struct nv50_pm_state *info = exec->priv;
 437         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 438
 439         hwsq_wr32(hwsq, 0x100210, enable ? 0x80000000 : 0x00000000);
 440 }
 441
 442 static void
 443 mclk_refresh_self(struct nouveau_mem_exec_func *exec, bool enable)
 444 {
 445         struct nv50_pm_state *info = exec->priv;
 446         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 447
 448         hwsq_wr32(hwsq, 0x1002dc, enable ? 0x00000001 : 0x00000000);
 449 }
 450
 451 static void
 452 mclk_wait(struct nouveau_mem_exec_func *exec, u32 nsec)
 453 {
 454         struct nv50_pm_state *info = exec->priv;
 455         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 456
 457         if (nsec > 1000)
 458                 hwsq_usec(hwsq, (nsec + 500) / 1000);
 459 }
 460
 461 static u32
 462 mclk_mrg(struct nouveau_mem_exec_func *exec, int mr)
 463 {
 464         if (mr <= 1)
 465                 return nv_rd32(exec->dev, 0x1002c0 + ((mr - 0) * 4));
 466         if (mr <= 3)
 467                 return nv_rd32(exec->dev, 0x1002e0 + ((mr - 2) * 4));
 468         return 0;
 469 }
 470
 471 static void
 472 mclk_mrs(struct nouveau_mem_exec_func *exec, int mr, u32 data)
 473 {
 474         struct drm_nouveau_private *dev_priv = exec->dev->dev_private;
 475         struct nv50_pm_state *info = exec->priv;
 476         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 477
 478         if (mr <= 1) {
 479                 if (dev_priv->vram_rank_B)
 480                         hwsq_wr32(hwsq, 0x1002c8 + ((mr - 0) * 4), data);
 481                 hwsq_wr32(hwsq, 0x1002c0 + ((mr - 0) * 4), data);
 482         } else
 483         if (mr <= 3) {
 484                 if (dev_priv->vram_rank_B)
 485                         hwsq_wr32(hwsq, 0x1002e8 + ((mr - 2) * 4), data);
 486                 hwsq_wr32(hwsq, 0x1002e0 + ((mr - 2) * 4), data);
 487         }
 488 }
 489
 490 static void
 491 mclk_clock_set(struct nouveau_mem_exec_func *exec)
 492 {
 493         struct nv50_pm_state *info = exec->priv;
 494         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 495         u32 ctrl = nv_rd32(exec->dev, 0x004008);
 496
 497         info->mmast = nv_rd32(exec->dev, 0x00c040);
 498         info->mmast &= ~0xc0000000; /* get MCLK_2 from HREF */
 499         info->mmast |=  0x0000c000; /* use MCLK_2 as MPLL_BYPASS clock */
 500
 501         hwsq_wr32(hwsq, 0xc040, info->mmast);
 502         hwsq_wr32(hwsq, 0x4008, ctrl | 0x00000200); /* bypass MPLL */
 503         if (info->mctrl & 0x80000000)
 504                 hwsq_wr32(hwsq, 0x400c, info->mcoef);
 505         hwsq_wr32(hwsq, 0x4008, info->mctrl);
 506 }
 507
 508 static void
 509 mclk_timing_set(struct nouveau_mem_exec_func *exec)
 510 {
 511         struct drm_device *dev = exec->dev;
 512         struct nv50_pm_state *info = exec->priv;
 513         struct nouveau_pm_level *perflvl = info->perflvl;
 514         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 515         int i;
 516
 517         for (i = 0; i < 9; i++) {
 518                 u32 reg = 0x100220 + (i * 4);
 519                 u32 val = nv_rd32(dev, reg);
 520                 if (val != perflvl->timing.reg[i])
 521                         hwsq_wr32(hwsq, reg, perflvl->timing.reg[i]);
 522         }
 523 }
 524
 525 static int
 526 calc_mclk(struct drm_device *dev, struct nouveau_pm_level *perflvl,
 527           struct nv50_pm_state *info)
 528 {
 529         struct drm_nouveau_private *dev_priv = dev->dev_private;
 530         u32 crtc_mask = nv50_display_active_crtcs(dev);
 531         struct nouveau_mem_exec_func exec = {
 532                 .dev = dev,
 533                 .precharge = mclk_precharge,
 534                 .refresh = mclk_refresh,
 535                 .refresh_auto = mclk_refresh_auto,
 536                 .refresh_self = mclk_refresh_self,
 537                 .wait = mclk_wait,
 538                 .mrg = mclk_mrg,
 539                 .mrs = mclk_mrs,
 540                 .clock_set = mclk_clock_set,
 541                 .timing_set = mclk_timing_set,
 542                 .priv = info
 543         };
 544         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 545         struct pll_lims pll;
 546         int N, M, P;
 547         int ret;
 548
 549         /* use pcie refclock if possible, otherwise use mpll */
 550         info->mctrl  = nv_rd32(dev, 0x004008);
 551         info->mctrl &= ~0x81ff0200;
 552         if (clk_same(perflvl->memory, read_clk(dev, clk_src_href))) {
 553                 info->mctrl |= 0x00000200 | (pll.log2p_bias << 19);
 554         } else {
 555                 ret = calc_pll(dev, 0x4008, &pll, perflvl->memory, &N, &M, &P);
 556                 if (ret == 0)
 557                         return -EINVAL;
 558
 559                 info->mctrl |= 0x80000000 | (P << 22) | (P << 16);
 560                 info->mctrl |= pll.log2p_bias << 19;
 561                 info->mcoef  = (N << 8) | M;
 562         }
 563
 564         /* build the ucode which will reclock the memory for us */
 565         hwsq_init(hwsq);
 566         if (crtc_mask) {
 567                 hwsq_op5f(hwsq, crtc_mask, 0x00); /* wait for scanout */
 568                 hwsq_op5f(hwsq, crtc_mask, 0x01); /* wait for vblank */
 569         }
 570         if (dev_priv->chipset >= 0x92)
 571                 hwsq_wr32(hwsq, 0x611200, 0x00003300); /* disable scanout */
 572         hwsq_setf(hwsq, 0x10, 0); /* disable bus access */
 573         hwsq_op5f(hwsq, 0x00, 0x01); /* no idea :s */
 574
 575         ret = nouveau_mem_exec(&exec, perflvl);
 576         if (ret)
 577                 return ret;
 578
 579         hwsq_setf(hwsq, 0x10, 1); /* enable bus access */
 580         hwsq_op5f(hwsq, 0x00, 0x00); /* no idea, reverse of 0x00, 0x01? */
 581         if (dev_priv->chipset >= 0x92)
 582                 hwsq_wr32(hwsq, 0x611200, 0x00003330); /* enable scanout */
 583         hwsq_fini(hwsq);
 584         return 0;
 585 }
 586
 587 void *
 588 nv50_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 589 {
 590         struct drm_nouveau_private *dev_priv = dev->dev_private;
 591         struct nv50_pm_state *info;
 592         struct hwsq_ucode *hwsq;
 593         struct pll_lims pll;
 594         u32 out, mast, divs, ctrl;
 595         int clk, ret = -EINVAL;
 596         int N, M, P1, P2;
 597
 598         if (dev_priv->chipset == 0xaa ||
 599             dev_priv->chipset == 0xac)
 600                 return ERR_PTR(-ENODEV);
 601
 602         info = kmalloc(sizeof(*info), GFP_KERNEL);
 603         if (!info)
 604                 return ERR_PTR(-ENOMEM);
 605         info->perflvl = perflvl;
 606
 607         /* memory: build hwsq ucode which we'll use to reclock memory.
 608          *         use pcie refclock if possible, otherwise use mpll */
 609         info->mclk_hwsq.len = 0;
 610         if (perflvl->memory) {
 611                 ret = calc_mclk(dev, perflvl, info);
 612                 if (ret)
 613                         goto error;
 614                 info->mscript = perflvl->memscript;
 615         }
 616
 617         divs = read_div(dev);
 618         mast = info->mmast;
 619
 620         /* start building HWSQ script for engine reclocking */
 621         hwsq = &info->eclk_hwsq;
 622         hwsq_init(hwsq);
 623         hwsq_setf(hwsq, 0x10, 0); /* disable bus access */
 624         hwsq_op5f(hwsq, 0x00, 0x01); /* wait for access disabled? */
 625
 626         /* vdec/dom6: switch to "safe" clocks temporarily */
 627         if (perflvl->vdec) {
 628                 mast &= ~0x00000c00;
 629                 divs &= ~0x00000700;
 630         }
 631
 632         if (perflvl->dom6) {
 633                 mast &= ~0x0c000000;
 634                 divs &= ~0x00000007;
 635         }
 636
 637         hwsq_wr32(hwsq, 0x00c040, mast);
 638
 639         /* vdec: avoid modifying xpll until we know exactly how the other
 640          * clock domains work, i suspect at least some of them can also be
 641          * tied to xpll...
 642          */
 643         if (perflvl->vdec) {
 644                 /* see how close we can get using nvclk as a source */
 645                 clk = calc_div(perflvl->core, perflvl->vdec, &P1);
 646
 647                 /* see how close we can get using xpll/hclk as a source */
 648                 if (dev_priv->chipset != 0x98)
 649                         out = read_pll(dev, 0x004030);
 650                 else
 651                         out = read_clk(dev, clk_src_hclkm3d2);
 652                 out = calc_div(out, perflvl->vdec, &P2);
 653
 654                 /* select whichever gets us closest */
 655                 if (abs((int)perflvl->vdec - clk) <=
 656                     abs((int)perflvl->vdec - out)) {
 657                         if (dev_priv->chipset != 0x98)
 658                                 mast |= 0x00000c00;
 659                         divs |= P1 << 8;
 660                 } else {
 661                         mast |= 0x00000800;
 662                         divs |= P2 << 8;
 663                 }
 664         }
 665
 666         /* dom6: nfi what this is, but we're limited to various combinations
 667          * of the host clock frequency
 668          */
 669         if (perflvl->dom6) {
 670                 if (clk_same(perflvl->dom6, read_clk(dev, clk_src_href))) {
 671                         mast |= 0x00000000;
 672                 } else
 673                 if (clk_same(perflvl->dom6, read_clk(dev, clk_src_hclk))) {
 674                         mast |= 0x08000000;
 675                 } else {
 676                         clk = read_clk(dev, clk_src_hclk) * 3;
 677                         clk = calc_div(clk, perflvl->dom6, &P1);
 678
 679                         mast |= 0x0c000000;
 680                         divs |= P1;
 681                 }
 682         }
 683
 684         /* vdec/dom6: complete switch to new clocks */
 685         switch (dev_priv->chipset) {
 686         case 0x92:
 687         case 0x94:
 688         case 0x96:
 689                 hwsq_wr32(hwsq, 0x004800, divs);
 690                 break;
 691         default:
 692                 hwsq_wr32(hwsq, 0x004700, divs);
 693                 break;
 694         }
 695
 696         hwsq_wr32(hwsq, 0x00c040, mast);
 697
 698         /* core/shader: make sure sclk/nvclk are disconnected from their
 699          * PLLs (nvclk to dom6, sclk to hclk)
 700          */
 701         if (dev_priv->chipset < 0x92)
 702                 mast = (mast & ~0x001000b0) | 0x00100080;
 703         else
 704                 mast = (mast & ~0x000000b3) | 0x00000081;
 705
 706         hwsq_wr32(hwsq, 0x00c040, mast);
 707
 708         /* core: for the moment at least, always use nvpll */
 709         clk = calc_pll(dev, 0x4028, &pll, perflvl->core, &N, &M, &P1);
 710         if (clk == 0)
 711                 goto error;
 712
 713         ctrl  = nv_rd32(dev, 0x004028) & ~0xc03f0100;
 714         mast &= ~0x00100000;
 715         mast |= 3;
 716
 717         hwsq_wr32(hwsq, 0x004028, 0x80000000 | (P1 << 19) | (P1 << 16) | ctrl);
 718         hwsq_wr32(hwsq, 0x00402c, (N << 8) | M);
 719
 720         /* shader: tie to nvclk if possible, otherwise use spll.  have to be
 721          * very careful that the shader clock is at least twice the core, or
 722          * some chipsets will be very unhappy.  i expect most or all of these
 723          * cases will be handled by tying to nvclk, but it's possible there's
 724          * corners
 725          */
 726         ctrl = nv_rd32(dev, 0x004020) & ~0xc03f0100;
 727
 728         if (P1-- && perflvl->shader == (perflvl->core << 1)) {
 729                 hwsq_wr32(hwsq, 0x004020, (P1 << 19) | (P1 << 16) | ctrl);
 730                 hwsq_wr32(hwsq, 0x00c040, 0x00000020 | mast);
 731         } else {
 732                 clk = calc_pll(dev, 0x4020, &pll, perflvl->shader, &N, &M, &P1);
 733                 if (clk == 0)
 734                         goto error;
 735                 ctrl |= 0x80000000;
 736
 737                 hwsq_wr32(hwsq, 0x004020, (P1 << 19) | (P1 << 16) | ctrl);
 738                 hwsq_wr32(hwsq, 0x004024, (N << 8) | M);
 739                 hwsq_wr32(hwsq, 0x00c040, 0x00000030 | mast);
 740         }
 741
 742         hwsq_setf(hwsq, 0x10, 1); /* enable bus access */
 743         hwsq_op5f(hwsq, 0x00, 0x00); /* wait for access enabled? */
 744         hwsq_fini(hwsq);
 745
 746         return info;
 747 error:
 748         kfree(info);
 749         return ERR_PTR(ret);
 750 }
 751
 752 static int
 753 prog_hwsq(struct drm_device *dev, struct hwsq_ucode *hwsq)
 754 {
 755         struct drm_nouveau_private *dev_priv = dev->dev_private;
 756         u32 hwsq_data, hwsq_kick;
 757         int i;
 758
 759         if (dev_priv->chipset < 0x94) {
 760                 hwsq_data = 0x001400;
 761                 hwsq_kick = 0x00000003;
 762         } else {
 763                 hwsq_data = 0x080000;
 764                 hwsq_kick = 0x00000001;
 765         }
 766         /* upload hwsq ucode */
 767         nv_mask(dev, 0x001098, 0x00000008, 0x00000000);
 768         nv_wr32(dev, 0x001304, 0x00000000);
 769         if (dev_priv->chipset >= 0x92)
 770                 nv_wr32(dev, 0x001318, 0x00000000);
 771         for (i = 0; i < hwsq->len / 4; i++)
 772                 nv_wr32(dev, hwsq_data + (i * 4), hwsq->ptr.u32[i]);
 773         nv_mask(dev, 0x001098, 0x00000018, 0x00000018);
 774
 775         /* launch, and wait for completion */
 776         nv_wr32(dev, 0x00130c, hwsq_kick);
 777         if (!nv_wait(dev, 0x001308, 0x00000100, 0x00000000)) {
 778                 NV_ERROR(dev, "hwsq ucode exec timed out\n");
 779                 NV_ERROR(dev, "0x001308: 0x%08x\n", nv_rd32(dev, 0x001308));
 780                 for (i = 0; i < hwsq->len / 4; i++) {
 781                         NV_ERROR(dev, "0x%06x: 0x%08x\n", 0x1400 + (i * 4),
 782                                  nv_rd32(dev, 0x001400 + (i * 4)));
 783                 }
 784
 785                 return -EIO;
 786         }
 787
 788         return 0;
 789 }
 790
 791 int
 792 nv50_pm_clocks_set(struct drm_device *dev, void *data)
 793 {
 794         struct nv50_pm_state *info = data;
 795         struct bit_entry M;
 796         int ret = -EBUSY;
 797
 798         /* halt and idle execution engines */
 799         nv_mask(dev, 0x002504, 0x00000001, 0x00000001);
 800         if (!nv_wait(dev, 0x002504, 0x00000010, 0x00000010))
 801                 goto resume;
 802         if (!nv_wait(dev, 0x00251c, 0x0000003f, 0x0000003f))
 803                 goto resume;
 804
 805         /* program memory clock, if necessary - must come before engine clock
 806          * reprogramming due to how we construct the hwsq scripts in pre()
 807          */
 808         if (info->mclk_hwsq.len) {
 809                 /* execute some scripts that do ??? from the vbios.. */
 810                 if (!bit_table(dev, 'M', &M) && M.version == 1) {
 811                         if (M.length >= 6)
 812                                 nouveau_bios_init_exec(dev, ROM16(M.data[5]));
 813                         if (M.length >= 8)
 814                                 nouveau_bios_init_exec(dev, ROM16(M.data[7]));
 815                         if (M.length >= 10)
 816                                 nouveau_bios_init_exec(dev, ROM16(M.data[9]));
 817                         nouveau_bios_init_exec(dev, info->mscript);
 818                 }
 819
 820                 ret = prog_hwsq(dev, &info->mclk_hwsq);
 821                 if (ret)
 822                         goto resume;
 823         }
 824
 825         /* program engine clocks */
 826         ret = prog_hwsq(dev, &info->eclk_hwsq);
 827
 828 resume:
 829         nv_mask(dev, 0x002504, 0x00000001, 0x00000000);
 830         kfree(info);
 831         return ret;
 832 }
 833
 834 static int
 835 pwm_info(struct drm_device *dev, int *line, int *ctrl, int *indx)
 836 {
 837         if (*line == 0x04) {
 838                 *ctrl = 0x00e100;
 839                 *line = 4;
 840                 *indx = 0;
 841         } else
 842         if (*line == 0x09) {
 843                 *ctrl = 0x00e100;
 844                 *line = 9;
 845                 *indx = 1;
 846         } else
 847         if (*line == 0x10) {
 848                 *ctrl = 0x00e28c;
 849                 *line = 0;
 850                 *indx = 0;
 851         } else {
 852                 NV_ERROR(dev, "unknown pwm ctrl for gpio %d\n", *line);
 853                 return -ENODEV;
 854         }
 855
 856         return 0;
 857 }
 858
 859 int
 860 nv50_pm_pwm_get(struct drm_device *dev, int line, u32 *divs, u32 *duty)
 861 {
 862         int ctrl, id, ret = pwm_info(dev, &line, &ctrl, &id);
 863         if (ret)
 864                 return ret;
 865
 866         if (nv_rd32(dev, ctrl) & (1 << line)) {
 867                 *divs = nv_rd32(dev, 0x00e114 + (id * 8));
 868                 *duty = nv_rd32(dev, 0x00e118 + (id * 8));
 869                 return 0;
 870         }
 871
 872         return -EINVAL;
 873 }
 874
 875 int
 876 nv50_pm_pwm_set(struct drm_device *dev, int line, u32 divs, u32 duty)
 877 {
 878         int ctrl, id, ret = pwm_info(dev, &line, &ctrl, &id);
 879         if (ret)
 880                 return ret;
 881
 882         nv_mask(dev, ctrl, 0x00010001 << line, 0x00000001 << line);
 883         nv_wr32(dev, 0x00e114 + (id * 8), divs);
 884         nv_wr32(dev, 0x00e118 + (id * 8), duty | 0x80000000);
 885         return 0;
 886 }