drivers/gpu/drm/nouveau/core/subdev/fb/ramnve0.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
  25 #include <subdev/gpio.h>
  26
  27 #include <subdev/bios.h>
  28 #include <subdev/bios/pll.h>
  29 #include <subdev/bios/init.h>
  30 #include <subdev/bios/rammap.h>
  31 #include <subdev/bios/timing.h>
  32 #include <subdev/bios/M0205.h>
  33 #include <subdev/bios/M0209.h>
  34
  35 #include <subdev/clock.h>
  36 #include <subdev/clock/pll.h>
  37
  38 #include <subdev/timer.h>
  39
  40 #include <core/option.h>
  41
  42 #include "nvc0.h"
  43
  44 #include "ramfuc.h"
  45
  46 /* binary driver only executes this path if the condition (a) is true
  47  * for any configuration (combination of rammap+ramcfg+timing) that
  48  * can be reached on a given card.  for now, we will execute the branch
  49  * unconditionally in the hope that a "false everywhere" in the bios
  50  * tables doesn't actually mean "don't touch this".
  51  */
  52 #define NOTE00(a) 1
  53
  54 struct nve0_ramfuc {
  55         struct ramfuc base;
  56
  57         struct nvbios_pll refpll;
  58         struct nvbios_pll mempll;
  59
  60         struct ramfuc_reg r_gpioMV;
  61         u32 r_funcMV[2];
  62         struct ramfuc_reg r_gpio2E;
  63         u32 r_func2E[2];
  64         struct ramfuc_reg r_gpiotrig;
  65
  66         struct ramfuc_reg r_0x132020;
  67         struct ramfuc_reg r_0x132028;
  68         struct ramfuc_reg r_0x132024;
  69         struct ramfuc_reg r_0x132030;
  70         struct ramfuc_reg r_0x132034;
  71         struct ramfuc_reg r_0x132000;
  72         struct ramfuc_reg r_0x132004;
  73         struct ramfuc_reg r_0x132040;
  74
  75         struct ramfuc_reg r_0x10f248;
  76         struct ramfuc_reg r_0x10f290;
  77         struct ramfuc_reg r_0x10f294;
  78         struct ramfuc_reg r_0x10f298;
  79         struct ramfuc_reg r_0x10f29c;
  80         struct ramfuc_reg r_0x10f2a0;
  81         struct ramfuc_reg r_0x10f2a4;
  82         struct ramfuc_reg r_0x10f2a8;
  83         struct ramfuc_reg r_0x10f2ac;
  84         struct ramfuc_reg r_0x10f2cc;
  85         struct ramfuc_reg r_0x10f2e8;
  86         struct ramfuc_reg r_0x10f250;
  87         struct ramfuc_reg r_0x10f24c;
  88         struct ramfuc_reg r_0x10fec4;
  89         struct ramfuc_reg r_0x10fec8;
  90         struct ramfuc_reg r_0x10f604;
  91         struct ramfuc_reg r_0x10f614;
  92         struct ramfuc_reg r_0x10f610;
  93         struct ramfuc_reg r_0x100770;
  94         struct ramfuc_reg r_0x100778;
  95         struct ramfuc_reg r_0x10f224;
  96
  97         struct ramfuc_reg r_0x10f870;
  98         struct ramfuc_reg r_0x10f698;
  99         struct ramfuc_reg r_0x10f694;
 100         struct ramfuc_reg r_0x10f6b8;
 101         struct ramfuc_reg r_0x10f808;
 102         struct ramfuc_reg r_0x10f670;
 103         struct ramfuc_reg r_0x10f60c;
 104         struct ramfuc_reg r_0x10f830;
 105         struct ramfuc_reg r_0x1373ec;
 106         struct ramfuc_reg r_0x10f800;
 107         struct ramfuc_reg r_0x10f82c;
 108
 109         struct ramfuc_reg r_0x10f978;
 110         struct ramfuc_reg r_0x10f910;
 111         struct ramfuc_reg r_0x10f914;
 112
 113         struct ramfuc_reg r_mr[16]; /* MR0 - MR8, MR15 */
 114
 115         struct ramfuc_reg r_0x62c000;
 116
 117         struct ramfuc_reg r_0x10f200;
 118
 119         struct ramfuc_reg r_0x10f210;
 120         struct ramfuc_reg r_0x10f310;
 121         struct ramfuc_reg r_0x10f314;
 122         struct ramfuc_reg r_0x10f318;
 123         struct ramfuc_reg r_0x10f090;
 124         struct ramfuc_reg r_0x10f69c;
 125         struct ramfuc_reg r_0x10f824;
 126         struct ramfuc_reg r_0x1373f0;
 127         struct ramfuc_reg r_0x1373f4;
 128         struct ramfuc_reg r_0x137320;
 129         struct ramfuc_reg r_0x10f65c;
 130         struct ramfuc_reg r_0x10f6bc;
 131         struct ramfuc_reg r_0x100710;
 132         struct ramfuc_reg r_0x100750;
 133 };
 134
 135 struct nve0_ram {
 136         struct nouveau_ram base;
 137         struct nve0_ramfuc fuc;
 138
 139         u32 parts;
 140         u32 pmask;
 141         u32 pnuts;
 142
 143         int from;
 144         int mode;
 145         int N1, fN1, M1, P1;
 146         int N2, M2, P2;
 147 };
 148
 149 /*******************************************************************************
 150  * GDDR5
 151  ******************************************************************************/
 152 static void
 153 nve0_ram_train(struct nve0_ramfuc *fuc, u32 mask, u32 data)
 154 {
 155         struct nve0_ram *ram = container_of(fuc, typeof(*ram), fuc);
 156         u32 addr = 0x110974, i;
 157
 158         ram_mask(fuc, 0x10f910, mask, data);
 159         ram_mask(fuc, 0x10f914, mask, data);
 160
 161         for (i = 0; (data & 0x80000000) && i < ram->parts; addr += 0x1000, i++) {
 162                 if (ram->pmask & (1 << i))
 163                         continue;
 164                 ram_wait(fuc, addr, 0x0000000f, 0x00000000, 500000);
 165         }
 166 }
 167
 168 static void
 169 r1373f4_init(struct nve0_ramfuc *fuc)
 170 {
 171         struct nve0_ram *ram = container_of(fuc, typeof(*ram), fuc);
 172         const u32 mcoef = ((--ram->P2 << 28) | (ram->N2 << 8) | ram->M2);
 173         const u32 rcoef = ((  ram->P1 << 16) | (ram->N1 << 8) | ram->M1);
 174         const u32 runk0 = ram->fN1 << 16;
 175         const u32 runk1 = ram->fN1;
 176
 177         if (ram->from == 2) {
 178                 ram_mask(fuc, 0x1373f4, 0x00000000, 0x00001100);
 179                 ram_mask(fuc, 0x1373f4, 0x00000000, 0x00000010);
 180         } else {
 181                 ram_mask(fuc, 0x1373f4, 0x00000000, 0x00010010);
 182         }
 183
 184         ram_mask(fuc, 0x1373f4, 0x00000003, 0x00000000);
 185         ram_mask(fuc, 0x1373f4, 0x00000010, 0x00000000);
 186
 187         /* (re)program refpll, if required */
 188         if ((ram_rd32(fuc, 0x132024) & 0xffffffff) != rcoef ||
 189             (ram_rd32(fuc, 0x132034) & 0x0000ffff) != runk1) {
 190                 ram_mask(fuc, 0x132000, 0x00000001, 0x00000000);
 191                 ram_mask(fuc, 0x132020, 0x00000001, 0x00000000);
 192                 ram_wr32(fuc, 0x137320, 0x00000000);
 193                 ram_mask(fuc, 0x132030, 0xffff0000, runk0);
 194                 ram_mask(fuc, 0x132034, 0x0000ffff, runk1);
 195                 ram_wr32(fuc, 0x132024, rcoef);
 196                 ram_mask(fuc, 0x132028, 0x00080000, 0x00080000);
 197                 ram_mask(fuc, 0x132020, 0x00000001, 0x00000001);
 198                 ram_wait(fuc, 0x137390, 0x00020000, 0x00020000, 64000);
 199                 ram_mask(fuc, 0x132028, 0x00080000, 0x00000000);
 200         }
 201
 202         /* (re)program mempll, if required */
 203         if (ram->mode == 2) {
 204                 ram_mask(fuc, 0x1373f4, 0x00010000, 0x00000000);
 205                 ram_mask(fuc, 0x132000, 0x80000000, 0x80000000);
 206                 ram_mask(fuc, 0x132000, 0x00000001, 0x00000000);
 207                 ram_mask(fuc, 0x132004, 0x103fffff, mcoef);
 208                 ram_mask(fuc, 0x132000, 0x00000001, 0x00000001);
 209                 ram_wait(fuc, 0x137390, 0x00000002, 0x00000002, 64000);
 210                 ram_mask(fuc, 0x1373f4, 0x00000000, 0x00001100);
 211         } else {
 212                 ram_mask(fuc, 0x1373f4, 0x00000000, 0x00010100);
 213         }
 214
 215         ram_mask(fuc, 0x1373f4, 0x00000000, 0x00000010);
 216 }
 217
 218 static void
 219 r1373f4_fini(struct nve0_ramfuc *fuc)
 220 {
 221         struct nve0_ram *ram = container_of(fuc, typeof(*ram), fuc);
 222         struct nouveau_ram_data *next = ram->base.next;
 223         u8 v0 = next->bios.ramcfg_11_03_c0;
 224         u8 v1 = next->bios.ramcfg_11_03_30;
 225         u32 tmp;
 226
 227         tmp = ram_rd32(fuc, 0x1373ec) & ~0x00030000;
 228         ram_wr32(fuc, 0x1373ec, tmp | (v1 << 16));
 229         ram_mask(fuc, 0x1373f0, (~ram->mode & 3), 0x00000000);
 230         if (ram->mode == 2) {
 231                 ram_mask(fuc, 0x1373f4, 0x00000003, 0x000000002);
 232                 ram_mask(fuc, 0x1373f4, 0x00001100, 0x000000000);
 233         } else {
 234                 ram_mask(fuc, 0x1373f4, 0x00000003, 0x000000001);
 235                 ram_mask(fuc, 0x1373f4, 0x00010000, 0x000000000);
 236         }
 237         ram_mask(fuc, 0x10f800, 0x00000030, (v0 ^ v1) << 4);
 238 }
 239
 240 static void
 241 nve0_ram_nuts(struct nve0_ram *ram, struct ramfuc_reg *reg,
 242               u32 _mask, u32 _data, u32 _copy)
 243 {
 244         struct nve0_fb_priv *priv = (void *)nouveau_fb(ram);
 245         struct ramfuc *fuc = &ram->fuc.base;
 246         u32 addr = 0x110000 + (reg->addr[0] & 0xfff);
 247         u32 mask = _mask | _copy;
 248         u32 data = (_data & _mask) | (reg->data & _copy);
 249         u32 i;
 250
 251         for (i = 0; i < 16; i++, addr += 0x1000) {
 252                 if (ram->pnuts & (1 << i)) {
 253                         u32 prev = nv_rd32(priv, addr);
 254                         u32 next = (prev & ~mask) | data;
 255                         nouveau_memx_wr32(fuc->memx, addr, next);
 256                 }
 257         }
 258 }
 259 #define ram_nuts(s,r,m,d,c)                                                    \
 260         nve0_ram_nuts((s), &(s)->fuc.r_##r, (m), (d), (c))
 261
 262 static int
 263 nve0_ram_calc_gddr5(struct nouveau_fb *pfb, u32 freq)
 264 {
 265         struct nve0_ram *ram = (void *)pfb->ram;
 266         struct nve0_ramfuc *fuc = &ram->fuc;
 267         struct nouveau_ram_data *next = ram->base.next;
 268         int vc = !next->bios.ramcfg_11_02_08;
 269         int mv = !next->bios.ramcfg_11_02_04;
 270         u32 mask, data;
 271
 272         ram_mask(fuc, 0x10f808, 0x40000000, 0x40000000);
 273         ram_wr32(fuc, 0x62c000, 0x0f0f0000);
 274
 275         /* MR1: turn termination on early, for some reason.. */
 276         if ((ram->base.mr[1] & 0x03c) != 0x030) {
 277                 ram_mask(fuc, mr[1], 0x03c, ram->base.mr[1] & 0x03c);
 278                 ram_nuts(ram, mr[1], 0x03c, ram->base.mr1_nuts & 0x03c, 0x000);
 279         }
 280
 281         if (vc == 1 && ram_have(fuc, gpio2E)) {
 282                 u32 temp  = ram_mask(fuc, gpio2E, 0x3000, fuc->r_func2E[1]);
 283                 if (temp != ram_rd32(fuc, gpio2E)) {
 284                         ram_wr32(fuc, gpiotrig, 1);
 285                         ram_nsec(fuc, 20000);
 286                 }
 287         }
 288
 289         ram_mask(fuc, 0x10f200, 0x00000800, 0x00000000);
 290
 291         nve0_ram_train(fuc, 0x01020000, 0x000c0000);
 292
 293         ram_wr32(fuc, 0x10f210, 0x00000000); /* REFRESH_AUTO = 0 */
 294         ram_nsec(fuc, 1000);
 295         ram_wr32(fuc, 0x10f310, 0x00000001); /* REFRESH */
 296         ram_nsec(fuc, 1000);
 297
 298         ram_mask(fuc, 0x10f200, 0x80000000, 0x80000000);
 299         ram_wr32(fuc, 0x10f314, 0x00000001); /* PRECHARGE */
 300         ram_mask(fuc, 0x10f200, 0x80000000, 0x00000000);
 301         ram_wr32(fuc, 0x10f090, 0x00000061);
 302         ram_wr32(fuc, 0x10f090, 0xc000007f);
 303         ram_nsec(fuc, 1000);
 304
 305         ram_wr32(fuc, 0x10f698, 0x00000000);
 306         ram_wr32(fuc, 0x10f69c, 0x00000000);
 307
 308         /*XXX: there does appear to be some kind of condition here, simply
 309          *     modifying these bits in the vbios from the default pl0
 310          *     entries shows no change.  however, the data does appear to
 311          *     be correct and may be required for the transition back
 312          */
 313         mask = 0x800f07e0;
 314         data = 0x00030000;
 315         if (ram_rd32(fuc, 0x10f978) & 0x00800000)
 316                 data |= 0x00040000;
 317
 318         if (1) {
 319                 data |= 0x800807e0;
 320                 switch (next->bios.ramcfg_11_03_c0) {
 321                 case 3: data &= ~0x00000040; break;
 322                 case 2: data &= ~0x00000100; break;
 323                 case 1: data &= ~0x80000000; break;
 324                 case 0: data &= ~0x00000400; break;
 325                 }
 326
 327                 switch (next->bios.ramcfg_11_03_30) {
 328                 case 3: data &= ~0x00000020; break;
 329                 case 2: data &= ~0x00000080; break;
 330                 case 1: data &= ~0x00080000; break;
 331                 case 0: data &= ~0x00000200; break;
 332                 }
 333         }
 334
 335         if (next->bios.ramcfg_11_02_80)
 336                 mask |= 0x03000000;
 337         if (next->bios.ramcfg_11_02_40)
 338                 mask |= 0x00002000;
 339         if (next->bios.ramcfg_11_07_10)
 340                 mask |= 0x00004000;
 341         if (next->bios.ramcfg_11_07_08)
 342                 mask |= 0x00000003;
 343         else {
 344                 mask |= 0x34000000;
 345                 if (ram_rd32(fuc, 0x10f978) & 0x00800000)
 346                         mask |= 0x40000000;
 347         }
 348         ram_mask(fuc, 0x10f824, mask, data);
 349
 350         ram_mask(fuc, 0x132040, 0x00010000, 0x00000000);
 351
 352         if (ram->from == 2 && ram->mode != 2) {
 353                 ram_mask(fuc, 0x10f808, 0x00080000, 0x00000000);
 354                 ram_mask(fuc, 0x10f200, 0x18008000, 0x00008000);
 355                 ram_mask(fuc, 0x10f800, 0x00000000, 0x00000004);
 356                 ram_mask(fuc, 0x10f830, 0x00008000, 0x01040010);
 357                 ram_mask(fuc, 0x10f830, 0x01000000, 0x00000000);
 358                 r1373f4_init(fuc);
 359                 ram_mask(fuc, 0x1373f0, 0x00000002, 0x00000001);
 360                 r1373f4_fini(fuc);
 361                 ram_mask(fuc, 0x10f830, 0x00c00000, 0x00240001);
 362         } else
 363         if (ram->from != 2 && ram->mode != 2) {
 364                 r1373f4_init(fuc);
 365                 r1373f4_fini(fuc);
 366         }
 367
 368         if (ram_have(fuc, gpioMV)) {
 369                 u32 temp  = ram_mask(fuc, gpioMV, 0x3000, fuc->r_funcMV[mv]);
 370                 if (temp != ram_rd32(fuc, gpioMV)) {
 371                         ram_wr32(fuc, gpiotrig, 1);
 372                         ram_nsec(fuc, 64000);
 373                 }
 374         }
 375
 376         if (next->bios.ramcfg_11_02_40 ||
 377             next->bios.ramcfg_11_07_10) {
 378                 ram_mask(fuc, 0x132040, 0x00010000, 0x00010000);
 379                 ram_nsec(fuc, 20000);
 380         }
 381
 382         if (ram->from != 2 && ram->mode == 2) {
 383                 if (0 /*XXX: Titan */)
 384                         ram_mask(fuc, 0x10f200, 0x18000000, 0x18000000);
 385                 ram_mask(fuc, 0x10f800, 0x00000004, 0x00000000);
 386                 ram_mask(fuc, 0x1373f0, 0x00000000, 0x00000002);
 387                 ram_mask(fuc, 0x10f830, 0x00800001, 0x00408010);
 388                 r1373f4_init(fuc);
 389                 r1373f4_fini(fuc);
 390                 ram_mask(fuc, 0x10f808, 0x00000000, 0x00080000);
 391                 ram_mask(fuc, 0x10f200, 0x00808000, 0x00800000);
 392         } else
 393         if (ram->from == 2 && ram->mode == 2) {
 394                 ram_mask(fuc, 0x10f800, 0x00000004, 0x00000000);
 395                 r1373f4_init(fuc);
 396                 r1373f4_fini(fuc);
 397         }
 398
 399         if (ram->mode != 2) /*XXX*/ {
 400                 if (next->bios.ramcfg_11_07_40)
 401                         ram_mask(fuc, 0x10f670, 0x80000000, 0x80000000);
 402         }
 403
 404         ram_wr32(fuc, 0x10f65c, 0x00000011 * next->bios.rammap_11_11_0c);
 405         ram_wr32(fuc, 0x10f6b8, 0x01010101 * next->bios.ramcfg_11_09);
 406         ram_wr32(fuc, 0x10f6bc, 0x01010101 * next->bios.ramcfg_11_09);
 407
 408         if (!next->bios.ramcfg_11_07_08 && !next->bios.ramcfg_11_07_04) {
 409                 ram_wr32(fuc, 0x10f698, 0x01010101 * next->bios.ramcfg_11_04);
 410                 ram_wr32(fuc, 0x10f69c, 0x01010101 * next->bios.ramcfg_11_04);
 411         } else
 412         if (!next->bios.ramcfg_11_07_08) {
 413                 ram_wr32(fuc, 0x10f698, 0x00000000);
 414                 ram_wr32(fuc, 0x10f69c, 0x00000000);
 415         }
 416
 417         if (ram->mode != 2) {
 418                 u32 data = 0x01000100 * next->bios.ramcfg_11_04;
 419                 ram_nuke(fuc, 0x10f694);
 420                 ram_mask(fuc, 0x10f694, 0xff00ff00, data);
 421         }
 422
 423         if (ram->mode == 2 && next->bios.ramcfg_11_08_10)
 424                 data = 0x00000080;
 425         else
 426                 data = 0x00000000;
 427         ram_mask(fuc, 0x10f60c, 0x00000080, data);
 428
 429         mask = 0x00070000;
 430         data = 0x00000000;
 431         if (!next->bios.ramcfg_11_02_80)
 432                 data |= 0x03000000;
 433         if (!next->bios.ramcfg_11_02_40)
 434                 data |= 0x00002000;
 435         if (!next->bios.ramcfg_11_07_10)
 436                 data |= 0x00004000;
 437         if (!next->bios.ramcfg_11_07_08)
 438                 data |= 0x00000003;
 439         else
 440                 data |= 0x74000000;
 441         ram_mask(fuc, 0x10f824, mask, data);
 442
 443         if (next->bios.ramcfg_11_01_08)
 444                 data = 0x00000000;
 445         else
 446                 data = 0x00001000;
 447         ram_mask(fuc, 0x10f200, 0x00001000, data);
 448
 449         if (ram_rd32(fuc, 0x10f670) & 0x80000000) {
 450                 ram_nsec(fuc, 10000);
 451                 ram_mask(fuc, 0x10f670, 0x80000000, 0x00000000);
 452         }
 453
 454         if (next->bios.ramcfg_11_08_01)
 455                 data = 0x00100000;
 456         else
 457                 data = 0x00000000;
 458         ram_mask(fuc, 0x10f82c, 0x00100000, data);
 459
 460         data = 0x00000000;
 461         if (next->bios.ramcfg_11_08_08)
 462                 data |= 0x00002000;
 463         if (next->bios.ramcfg_11_08_04)
 464                 data |= 0x00001000;
 465         if (next->bios.ramcfg_11_08_02)
 466                 data |= 0x00004000;
 467         ram_mask(fuc, 0x10f830, 0x00007000, data);
 468
 469         /* PFB timing */
 470         ram_mask(fuc, 0x10f248, 0xffffffff, next->bios.timing[10]);
 471         ram_mask(fuc, 0x10f290, 0xffffffff, next->bios.timing[0]);
 472         ram_mask(fuc, 0x10f294, 0xffffffff, next->bios.timing[1]);
 473         ram_mask(fuc, 0x10f298, 0xffffffff, next->bios.timing[2]);
 474         ram_mask(fuc, 0x10f29c, 0xffffffff, next->bios.timing[3]);
 475         ram_mask(fuc, 0x10f2a0, 0xffffffff, next->bios.timing[4]);
 476         ram_mask(fuc, 0x10f2a4, 0xffffffff, next->bios.timing[5]);
 477         ram_mask(fuc, 0x10f2a8, 0xffffffff, next->bios.timing[6]);
 478         ram_mask(fuc, 0x10f2ac, 0xffffffff, next->bios.timing[7]);
 479         ram_mask(fuc, 0x10f2cc, 0xffffffff, next->bios.timing[8]);
 480         ram_mask(fuc, 0x10f2e8, 0xffffffff, next->bios.timing[9]);
 481
 482         data = mask = 0x00000000;
 483         if (NOTE00(ramcfg_08_20)) {
 484                 if (next->bios.ramcfg_11_08_20)
 485                         data |= 0x01000000;
 486                 mask |= 0x01000000;
 487         }
 488         ram_mask(fuc, 0x10f200, mask, data);
 489
 490         data = mask = 0x00000000;
 491         if (NOTE00(ramcfg_02_03 != 0)) {
 492                 data |= next->bios.ramcfg_11_02_03 << 8;
 493                 mask |= 0x00000300;
 494         }
 495         if (NOTE00(ramcfg_01_10)) {
 496                 if (next->bios.ramcfg_11_01_10)
 497                         data |= 0x70000000;
 498                 mask |= 0x70000000;
 499         }
 500         ram_mask(fuc, 0x10f604, mask, data);
 501
 502         data = mask = 0x00000000;
 503         if (NOTE00(timing_30_07 != 0)) {
 504                 data |= next->bios.timing_20_30_07 << 28;
 505                 mask |= 0x70000000;
 506         }
 507         if (NOTE00(ramcfg_01_01)) {
 508                 if (next->bios.ramcfg_11_01_01)
 509                         data |= 0x00000100;
 510                 mask |= 0x00000100;
 511         }
 512         ram_mask(fuc, 0x10f614, mask, data);
 513
 514         data = mask = 0x00000000;
 515         if (NOTE00(timing_30_07 != 0)) {
 516                 data |= next->bios.timing_20_30_07 << 28;
 517                 mask |= 0x70000000;
 518         }
 519         if (NOTE00(ramcfg_01_02)) {
 520                 if (next->bios.ramcfg_11_01_02)
 521                         data |= 0x00000100;
 522                 mask |= 0x00000100;
 523         }
 524         ram_mask(fuc, 0x10f610, mask, data);
 525
 526         mask = 0x33f00000;
 527         data = 0x00000000;
 528         if (!next->bios.ramcfg_11_01_04)
 529                 data |= 0x20200000;
 530         if (!next->bios.ramcfg_11_07_80)
 531                 data |= 0x12800000;
 532         /*XXX: see note above about there probably being some condition
 533          *     for the 10f824 stuff that uses ramcfg 3...
 534          */
 535         if (next->bios.ramcfg_11_03_f0) {
 536                 if (next->bios.rammap_11_08_0c) {
 537                         if (!next->bios.ramcfg_11_07_80)
 538                                 mask |= 0x00000020;
 539                         else
 540                                 data |= 0x00000020;
 541                         mask |= 0x00000004;
 542                 }
 543         } else {
 544                 mask |= 0x40000020;
 545                 data |= 0x00000004;
 546         }
 547
 548         ram_mask(fuc, 0x10f808, mask, data);
 549
 550         ram_wr32(fuc, 0x10f870, 0x11111111 * next->bios.ramcfg_11_03_0f);
 551
 552         data = mask = 0x00000000;
 553         if (NOTE00(ramcfg_02_03 != 0)) {
 554                 data |= next->bios.ramcfg_11_02_03;
 555                 mask |= 0x00000003;
 556         }
 557         if (NOTE00(ramcfg_01_10)) {
 558                 if (next->bios.ramcfg_11_01_10)
 559                         data |= 0x00000004;
 560                 mask |= 0x00000004;
 561         }
 562
 563         if ((ram_mask(fuc, 0x100770, mask, data) & mask & 4) != (data & 4)) {
 564                 ram_mask(fuc, 0x100750, 0x00000008, 0x00000008);
 565                 ram_wr32(fuc, 0x100710, 0x00000000);
 566                 ram_wait(fuc, 0x100710, 0x80000000, 0x80000000, 200000);
 567         }
 568
 569         data = next->bios.timing_20_30_07 << 8;
 570         if (next->bios.ramcfg_11_01_01)
 571                 data |= 0x80000000;
 572         ram_mask(fuc, 0x100778, 0x00000700, data);
 573
 574         ram_mask(fuc, 0x10f250, 0x000003f0, next->bios.timing_20_2c_003f << 4);
 575         data = (next->bios.timing[10] & 0x7f000000) >> 24;
 576         if (data < next->bios.timing_20_2c_1fc0)
 577                 data = next->bios.timing_20_2c_1fc0;
 578         ram_mask(fuc, 0x10f24c, 0x7f000000, data << 24);
 579         ram_mask(fuc, 0x10f224, 0x001f0000, next->bios.timing_20_30_f8 << 16);
 580
 581         ram_mask(fuc, 0x10fec4, 0x041e0f07, next->bios.timing_20_31_0800 << 26 |
 582                                             next->bios.timing_20_31_0780 << 17 |
 583                                             next->bios.timing_20_31_0078 << 8 |
 584                                             next->bios.timing_20_31_0007);
 585         ram_mask(fuc, 0x10fec8, 0x00000027, next->bios.timing_20_31_8000 << 5 |
 586                                             next->bios.timing_20_31_7000);
 587
 588         ram_wr32(fuc, 0x10f090, 0x4000007e);
 589         ram_nsec(fuc, 2000);
 590         ram_wr32(fuc, 0x10f314, 0x00000001); /* PRECHARGE */
 591         ram_wr32(fuc, 0x10f310, 0x00000001); /* REFRESH */
 592         ram_wr32(fuc, 0x10f210, 0x80000000); /* REFRESH_AUTO = 1 */
 593
 594         if (next->bios.ramcfg_11_08_10 && (ram->mode == 2) /*XXX*/) {
 595                 u32 temp = ram_mask(fuc, 0x10f294, 0xff000000, 0x24000000);
 596                 nve0_ram_train(fuc, 0xbc0e0000, 0xa4010000); /*XXX*/
 597                 ram_nsec(fuc, 1000);
 598                 ram_wr32(fuc, 0x10f294, temp);
 599         }
 600
 601         ram_mask(fuc, mr[3], 0xfff, ram->base.mr[3]);
 602         ram_wr32(fuc, mr[0], ram->base.mr[0]);
 603         ram_mask(fuc, mr[8], 0xfff, ram->base.mr[8]);
 604         ram_nsec(fuc, 1000);
 605         ram_mask(fuc, mr[1], 0xfff, ram->base.mr[1]);
 606         ram_mask(fuc, mr[5], 0xfff, ram->base.mr[5] & ~0x004); /* LP3 later */
 607         ram_mask(fuc, mr[6], 0xfff, ram->base.mr[6]);
 608         ram_mask(fuc, mr[7], 0xfff, ram->base.mr[7]);
 609
 610         if (vc == 0 && ram_have(fuc, gpio2E)) {
 611                 u32 temp  = ram_mask(fuc, gpio2E, 0x3000, fuc->r_func2E[0]);
 612                 if (temp != ram_rd32(fuc, gpio2E)) {
 613                         ram_wr32(fuc, gpiotrig, 1);
 614                         ram_nsec(fuc, 20000);
 615                 }
 616         }
 617
 618         ram_mask(fuc, 0x10f200, 0x80000000, 0x80000000);
 619         ram_wr32(fuc, 0x10f318, 0x00000001); /* NOP? */
 620         ram_mask(fuc, 0x10f200, 0x80000000, 0x00000000);
 621         ram_nsec(fuc, 1000);
 622         ram_nuts(ram, 0x10f200, 0x18808800, 0x00000000, 0x18808800);
 623
 624         data  = ram_rd32(fuc, 0x10f978);
 625         data &= ~0x00046144;
 626         data |=  0x0000000b;
 627         if (!next->bios.ramcfg_11_07_08) {
 628                 if (!next->bios.ramcfg_11_07_04)
 629                         data |= 0x0000200c;
 630                 else
 631                         data |= 0x00000000;
 632         } else {
 633                 data |= 0x00040044;
 634         }
 635         ram_wr32(fuc, 0x10f978, data);
 636
 637         if (ram->mode == 1) {
 638                 data = ram_rd32(fuc, 0x10f830) | 0x00000001;
 639                 ram_wr32(fuc, 0x10f830, data);
 640         }
 641
 642         if (!next->bios.ramcfg_11_07_08) {
 643                 data = 0x88020000;
 644                 if ( next->bios.ramcfg_11_07_04)
 645                         data |= 0x10000000;
 646                 if (!next->bios.rammap_11_08_10)
 647                         data |= 0x00080000;
 648         } else {
 649                 data = 0xa40e0000;
 650         }
 651         nve0_ram_train(fuc, 0xbc0f0000, data);
 652         if (1) /* XXX: not always? */
 653                 ram_nsec(fuc, 1000);
 654
 655         if (ram->mode == 2) { /*XXX*/
 656                 ram_mask(fuc, 0x10f800, 0x00000004, 0x00000004);
 657         }
 658
 659         /* LP3 */
 660         if (ram_mask(fuc, mr[5], 0x004, ram->base.mr[5]) != ram->base.mr[5])
 661                 ram_nsec(fuc, 1000);
 662
 663         if (ram->mode != 2) {
 664                 ram_mask(fuc, 0x10f830, 0x01000000, 0x01000000);
 665                 ram_mask(fuc, 0x10f830, 0x01000000, 0x00000000);
 666         }
 667
 668         if (next->bios.ramcfg_11_07_02)
 669                 nve0_ram_train(fuc, 0x80020000, 0x01000000);
 670
 671         ram_wr32(fuc, 0x62c000, 0x0f0f0f00);
 672
 673         if (next->bios.rammap_11_08_01)
 674                 data = 0x00000800;
 675         else
 676                 data = 0x00000000;
 677         ram_mask(fuc, 0x10f200, 0x00000800, data);
 678         ram_nuts(ram, 0x10f200, 0x18808800, data, 0x18808800);
 679         return 0;
 680 }
 681
 682 /*******************************************************************************
 683  * DDR3
 684  ******************************************************************************/
 685
 686 static int
 687 nve0_ram_calc_sddr3(struct nouveau_fb *pfb, u32 freq)
 688 {
 689         struct nve0_ram *ram = (void *)pfb->ram;
 690         struct nve0_ramfuc *fuc = &ram->fuc;
 691         const u32 rcoef = ((  ram->P1 << 16) | (ram->N1 << 8) | ram->M1);
 692         const u32 runk0 = ram->fN1 << 16;
 693         const u32 runk1 = ram->fN1;
 694         struct nouveau_ram_data *next = ram->base.next;
 695         int vc = !next->bios.ramcfg_11_02_08;
 696         int mv = !next->bios.ramcfg_11_02_04;
 697         u32 mask, data;
 698
 699         ram_mask(fuc, 0x10f808, 0x40000000, 0x40000000);
 700         ram_wr32(fuc, 0x62c000, 0x0f0f0000);
 701
 702         if (vc == 1 && ram_have(fuc, gpio2E)) {
 703                 u32 temp  = ram_mask(fuc, gpio2E, 0x3000, fuc->r_func2E[1]);
 704                 if (temp != ram_rd32(fuc, gpio2E)) {
 705                         ram_wr32(fuc, gpiotrig, 1);
 706                         ram_nsec(fuc, 20000);
 707                 }
 708         }
 709
 710         ram_mask(fuc, 0x10f200, 0x00000800, 0x00000000);
 711         if (next->bios.ramcfg_11_03_f0)
 712                 ram_mask(fuc, 0x10f808, 0x04000000, 0x04000000);
 713
 714         ram_wr32(fuc, 0x10f314, 0x00000001); /* PRECHARGE */
 715         ram_wr32(fuc, 0x10f210, 0x00000000); /* REFRESH_AUTO = 0 */
 716         ram_wr32(fuc, 0x10f310, 0x00000001); /* REFRESH */
 717         ram_mask(fuc, 0x10f200, 0x80000000, 0x80000000);
 718         ram_wr32(fuc, 0x10f310, 0x00000001); /* REFRESH */
 719         ram_mask(fuc, 0x10f200, 0x80000000, 0x00000000);
 720         ram_nsec(fuc, 1000);
 721
 722         ram_wr32(fuc, 0x10f090, 0x00000060);
 723         ram_wr32(fuc, 0x10f090, 0xc000007e);
 724
 725         /*XXX: there does appear to be some kind of condition here, simply
 726          *     modifying these bits in the vbios from the default pl0
 727          *     entries shows no change.  however, the data does appear to
 728          *     be correct and may be required for the transition back
 729          */
 730         mask = 0x00010000;
 731         data = 0x00010000;
 732
 733         if (1) {
 734                 mask |= 0x800807e0;
 735                 data |= 0x800807e0;
 736                 switch (next->bios.ramcfg_11_03_c0) {
 737                 case 3: data &= ~0x00000040; break;
 738                 case 2: data &= ~0x00000100; break;
 739                 case 1: data &= ~0x80000000; break;
 740                 case 0: data &= ~0x00000400; break;
 741                 }
 742
 743                 switch (next->bios.ramcfg_11_03_30) {
 744                 case 3: data &= ~0x00000020; break;
 745                 case 2: data &= ~0x00000080; break;
 746                 case 1: data &= ~0x00080000; break;
 747                 case 0: data &= ~0x00000200; break;
 748                 }
 749         }
 750
 751         if (next->bios.ramcfg_11_02_80)
 752                 mask |= 0x03000000;
 753         if (next->bios.ramcfg_11_02_40)
 754                 mask |= 0x00002000;
 755         if (next->bios.ramcfg_11_07_10)
 756                 mask |= 0x00004000;
 757         if (next->bios.ramcfg_11_07_08)
 758                 mask |= 0x00000003;
 759         else
 760                 mask |= 0x14000000;
 761         ram_mask(fuc, 0x10f824, mask, data);
 762
 763         ram_mask(fuc, 0x132040, 0x00010000, 0x00000000);
 764
 765         ram_mask(fuc, 0x1373f4, 0x00000000, 0x00010010);
 766         data  = ram_rd32(fuc, 0x1373ec) & ~0x00030000;
 767         data |= next->bios.ramcfg_11_03_30 << 16;
 768         ram_wr32(fuc, 0x1373ec, data);
 769         ram_mask(fuc, 0x1373f4, 0x00000003, 0x00000000);
 770         ram_mask(fuc, 0x1373f4, 0x00000010, 0x00000000);
 771
 772         /* (re)program refpll, if required */
 773         if ((ram_rd32(fuc, 0x132024) & 0xffffffff) != rcoef ||
 774             (ram_rd32(fuc, 0x132034) & 0x0000ffff) != runk1) {
 775                 ram_mask(fuc, 0x132000, 0x00000001, 0x00000000);
 776                 ram_mask(fuc, 0x132020, 0x00000001, 0x00000000);
 777                 ram_wr32(fuc, 0x137320, 0x00000000);
 778                 ram_mask(fuc, 0x132030, 0xffff0000, runk0);
 779                 ram_mask(fuc, 0x132034, 0x0000ffff, runk1);
 780                 ram_wr32(fuc, 0x132024, rcoef);
 781                 ram_mask(fuc, 0x132028, 0x00080000, 0x00080000);
 782                 ram_mask(fuc, 0x132020, 0x00000001, 0x00000001);
 783                 ram_wait(fuc, 0x137390, 0x00020000, 0x00020000, 64000);
 784                 ram_mask(fuc, 0x132028, 0x00080000, 0x00000000);
 785         }
 786
 787         ram_mask(fuc, 0x1373f4, 0x00000010, 0x00000010);
 788         ram_mask(fuc, 0x1373f4, 0x00000003, 0x00000001);
 789         ram_mask(fuc, 0x1373f4, 0x00010000, 0x00000000);
 790
 791         if (ram_have(fuc, gpioMV)) {
 792                 u32 temp  = ram_mask(fuc, gpioMV, 0x3000, fuc->r_funcMV[mv]);
 793                 if (temp != ram_rd32(fuc, gpioMV)) {
 794                         ram_wr32(fuc, gpiotrig, 1);
 795                         ram_nsec(fuc, 64000);
 796                 }
 797         }
 798
 799         if (next->bios.ramcfg_11_02_40 ||
 800             next->bios.ramcfg_11_07_10) {
 801                 ram_mask(fuc, 0x132040, 0x00010000, 0x00010000);
 802                 ram_nsec(fuc, 20000);
 803         }
 804
 805         if (ram->mode != 2) /*XXX*/ {
 806                 if (next->bios.ramcfg_11_07_40)
 807                         ram_mask(fuc, 0x10f670, 0x80000000, 0x80000000);
 808         }
 809
 810         ram_wr32(fuc, 0x10f65c, 0x00000011 * next->bios.rammap_11_11_0c);
 811         ram_wr32(fuc, 0x10f6b8, 0x01010101 * next->bios.ramcfg_11_09);
 812         ram_wr32(fuc, 0x10f6bc, 0x01010101 * next->bios.ramcfg_11_09);
 813
 814         mask = 0x00010000;
 815         data = 0x00000000;
 816         if (!next->bios.ramcfg_11_02_80)
 817                 data |= 0x03000000;
 818         if (!next->bios.ramcfg_11_02_40)
 819                 data |= 0x00002000;
 820         if (!next->bios.ramcfg_11_07_10)
 821                 data |= 0x00004000;
 822         if (!next->bios.ramcfg_11_07_08)
 823                 data |= 0x00000003;
 824         else
 825                 data |= 0x14000000;
 826         ram_mask(fuc, 0x10f824, mask, data);
 827         ram_nsec(fuc, 1000);
 828
 829         if (next->bios.ramcfg_11_08_01)
 830                 data = 0x00100000;
 831         else
 832                 data = 0x00000000;
 833         ram_mask(fuc, 0x10f82c, 0x00100000, data);
 834
 835         /* PFB timing */
 836         ram_mask(fuc, 0x10f248, 0xffffffff, next->bios.timing[10]);
 837         ram_mask(fuc, 0x10f290, 0xffffffff, next->bios.timing[0]);
 838         ram_mask(fuc, 0x10f294, 0xffffffff, next->bios.timing[1]);
 839         ram_mask(fuc, 0x10f298, 0xffffffff, next->bios.timing[2]);
 840         ram_mask(fuc, 0x10f29c, 0xffffffff, next->bios.timing[3]);
 841         ram_mask(fuc, 0x10f2a0, 0xffffffff, next->bios.timing[4]);
 842         ram_mask(fuc, 0x10f2a4, 0xffffffff, next->bios.timing[5]);
 843         ram_mask(fuc, 0x10f2a8, 0xffffffff, next->bios.timing[6]);
 844         ram_mask(fuc, 0x10f2ac, 0xffffffff, next->bios.timing[7]);
 845         ram_mask(fuc, 0x10f2cc, 0xffffffff, next->bios.timing[8]);
 846         ram_mask(fuc, 0x10f2e8, 0xffffffff, next->bios.timing[9]);
 847
 848         mask = 0x33f00000;
 849         data = 0x00000000;
 850         if (!next->bios.ramcfg_11_01_04)
 851                 data |= 0x20200000;
 852         if (!next->bios.ramcfg_11_07_80)
 853                 data |= 0x12800000;
 854         /*XXX: see note above about there probably being some condition
 855          *     for the 10f824 stuff that uses ramcfg 3...
 856          */
 857         if (next->bios.ramcfg_11_03_f0) {
 858                 if (next->bios.rammap_11_08_0c) {
 859                         if (!next->bios.ramcfg_11_07_80)
 860                                 mask |= 0x00000020;
 861                         else
 862                                 data |= 0x00000020;
 863                         mask |= 0x08000004;
 864                 }
 865                 data |= 0x04000000;
 866         } else {
 867                 mask |= 0x44000020;
 868                 data |= 0x08000004;
 869         }
 870
 871         ram_mask(fuc, 0x10f808, mask, data);
 872
 873         ram_wr32(fuc, 0x10f870, 0x11111111 * next->bios.ramcfg_11_03_0f);
 874
 875         ram_mask(fuc, 0x10f250, 0x000003f0, next->bios.timing_20_2c_003f << 4);
 876
 877         data = (next->bios.timing[10] & 0x7f000000) >> 24;
 878         if (data < next->bios.timing_20_2c_1fc0)
 879                 data = next->bios.timing_20_2c_1fc0;
 880         ram_mask(fuc, 0x10f24c, 0x7f000000, data << 24);
 881
 882         ram_mask(fuc, 0x10f224, 0x001f0000, next->bios.timing_20_30_f8 << 16);
 883
 884         ram_wr32(fuc, 0x10f090, 0x4000007f);
 885         ram_nsec(fuc, 1000);
 886
 887         ram_wr32(fuc, 0x10f314, 0x00000001); /* PRECHARGE */
 888         ram_wr32(fuc, 0x10f310, 0x00000001); /* REFRESH */
 889         ram_wr32(fuc, 0x10f210, 0x80000000); /* REFRESH_AUTO = 1 */
 890         ram_nsec(fuc, 1000);
 891
 892         ram_nuke(fuc, mr[0]);
 893         ram_mask(fuc, mr[0], 0x100, 0x100);
 894         ram_mask(fuc, mr[0], 0x100, 0x000);
 895
 896         ram_mask(fuc, mr[2], 0xfff, ram->base.mr[2]);
 897         ram_wr32(fuc, mr[0], ram->base.mr[0]);
 898         ram_nsec(fuc, 1000);
 899
 900         ram_nuke(fuc, mr[0]);
 901         ram_mask(fuc, mr[0], 0x100, 0x100);
 902         ram_mask(fuc, mr[0], 0x100, 0x000);
 903
 904         if (vc == 0 && ram_have(fuc, gpio2E)) {
 905                 u32 temp  = ram_mask(fuc, gpio2E, 0x3000, fuc->r_func2E[0]);
 906                 if (temp != ram_rd32(fuc, gpio2E)) {
 907                         ram_wr32(fuc, gpiotrig, 1);
 908                         ram_nsec(fuc, 20000);
 909                 }
 910         }
 911
 912         if (ram->mode != 2) {
 913                 ram_mask(fuc, 0x10f830, 0x01000000, 0x01000000);
 914                 ram_mask(fuc, 0x10f830, 0x01000000, 0x00000000);
 915         }
 916
 917         ram_mask(fuc, 0x10f200, 0x80000000, 0x80000000);
 918         ram_wr32(fuc, 0x10f318, 0x00000001); /* NOP? */
 919         ram_mask(fuc, 0x10f200, 0x80000000, 0x00000000);
 920         ram_nsec(fuc, 1000);
 921
 922         ram_wr32(fuc, 0x62c000, 0x0f0f0f00);
 923
 924         if (next->bios.rammap_11_08_01)
 925                 data = 0x00000800;
 926         else
 927                 data = 0x00000000;
 928         ram_mask(fuc, 0x10f200, 0x00000800, data);
 929         return 0;
 930 }
 931
 932 /*******************************************************************************
 933  * main hooks
 934  ******************************************************************************/
 935
 936 static int
 937 nve0_ram_calc_data(struct nouveau_fb *pfb, u32 freq,
 938                    struct nouveau_ram_data *data)
 939 {
 940         struct nouveau_bios *bios = nouveau_bios(pfb);
 941         struct nve0_ram *ram = (void *)pfb->ram;
 942         u8 strap, cnt, len;
 943
 944         /* lookup memory config data relevant to the target frequency */
 945         ram->base.rammap.data = nvbios_rammapEp(bios, freq / 1000,
 946                                                &ram->base.rammap.version,
 947                                                &ram->base.rammap.size,
 948                                                &cnt, &len, &data->bios);
 949         if (!ram->base.rammap.data || ram->base.rammap.version != 0x11 ||
 950              ram->base.rammap.size < 0x09) {
 951                 nv_error(pfb, "invalid/missing rammap entry\n");
 952                 return -EINVAL;
 953         }
 954
 955         /* locate specific data set for the attached memory */
 956         strap = nvbios_ramcfg_index(nv_subdev(pfb));
 957         ram->base.ramcfg.data = nvbios_rammapSp(bios, ram->base.rammap.data,
 958                                                 ram->base.rammap.version,
 959                                                 ram->base.rammap.size,
 960                                                 cnt, len, strap,
 961                                                 &ram->base.ramcfg.version,
 962                                                 &ram->base.ramcfg.size,
 963                                                 &data->bios);
 964         if (!ram->base.ramcfg.data || ram->base.ramcfg.version != 0x11 ||
 965              ram->base.ramcfg.size < 0x08) {
 966                 nv_error(pfb, "invalid/missing ramcfg entry\n");
 967                 return -EINVAL;
 968         }
 969
 970         /* lookup memory timings, if bios says they're present */
 971         strap = nv_ro08(bios, ram->base.ramcfg.data + 0x00);
 972         if (strap != 0xff) {
 973                 ram->base.timing.data =
 974                         nvbios_timingEp(bios, strap, &ram->base.timing.version,
 975                                        &ram->base.timing.size, &cnt, &len,
 976                                        &data->bios);
 977                 if (!ram->base.timing.data ||
 978                      ram->base.timing.version != 0x20 ||
 979                      ram->base.timing.size < 0x33) {
 980                         nv_error(pfb, "invalid/missing timing entry\n");
 981                         return -EINVAL;
 982                 }
 983         } else {
 984                 ram->base.timing.data = 0;
 985         }
 986
 987         data->freq = freq;
 988         return 0;
 989 }
 990
 991 static int
 992 nve0_ram_calc_xits(struct nouveau_fb *pfb, struct nouveau_ram_data *next)
 993 {
 994         struct nve0_ram *ram = (void *)pfb->ram;
 995         struct nve0_ramfuc *fuc = &ram->fuc;
 996         int refclk, i;
 997         int ret;
 998
 999         ret = ram_init(fuc, pfb);
1000         if (ret)
1001                 return ret;
1002
1003         ram_fb_disable(fuc);
1004
1005         ram->mode = (next->freq > fuc->refpll.vco1.max_freq) ? 2 : 1;
1006         ram->from = ram_rd32(fuc, 0x1373f4) & 0x0000000f;
1007
1008         /* XXX: this is *not* what nvidia do.  on fermi nvidia generally
1009          * select, based on some unknown condition, one of the two possible
1010          * reference frequencies listed in the vbios table for mempll and
1011          * program refpll to that frequency.
1012          *
1013          * so far, i've seen very weird values being chosen by nvidia on
1014          * kepler boards, no idea how/why they're chosen.
1015          */
1016         refclk = next->freq;
1017         if (ram->mode == 2)
1018                 refclk = fuc->mempll.refclk;
1019
1020         /* calculate refpll coefficients */
1021         ret = nva3_pll_calc(nv_subdev(pfb), &fuc->refpll, refclk, &ram->N1,
1022                            &ram->fN1, &ram->M1, &ram->P1);
1023         fuc->mempll.refclk = ret;
1024         if (ret <= 0) {
1025                 nv_error(pfb, "unable to calc refpll\n");
1026                 return -EINVAL;
1027         }
1028
1029         /* calculate mempll coefficients, if we're using it */
1030         if (ram->mode == 2) {
1031                 /* post-divider doesn't work... the reg takes the values but
1032                  * appears to completely ignore it.  there *is* a bit at
1033                  * bit 28 that appears to divide the clock by 2 if set.
1034                  */
1035                 fuc->mempll.min_p = 1;
1036                 fuc->mempll.max_p = 2;
1037
1038                 ret = nva3_pll_calc(nv_subdev(pfb), &fuc->mempll, next->freq,
1039                                    &ram->N2, NULL, &ram->M2, &ram->P2);
1040                 if (ret <= 0) {
1041                         nv_error(pfb, "unable to calc mempll\n");
1042                         return -EINVAL;
1043                 }
1044         }
1045
1046         for (i = 0; i < ARRAY_SIZE(fuc->r_mr); i++) {
1047                 if (ram_have(fuc, mr[i]))
1048                         ram->base.mr[i] = ram_rd32(fuc, mr[i]);
1049         }
1050         ram->base.freq = next->freq;
1051
1052         switch (ram->base.type) {
1053         case NV_MEM_TYPE_DDR3:
1054                 ret = nouveau_sddr3_calc(&ram->base);
1055                 if (ret == 0)
1056                         ret = nve0_ram_calc_sddr3(pfb, next->freq);
1057                 break;
1058         case NV_MEM_TYPE_GDDR5:
1059                 ret = nouveau_gddr5_calc(&ram->base, ram->pnuts != 0);
1060                 if (ret == 0)
1061                         ret = nve0_ram_calc_gddr5(pfb, next->freq);
1062                 break;
1063         default:
1064                 ret = -ENOSYS;
1065                 break;
1066         }
1067
1068         if (!ret)
1069                 ram_fb_enable(fuc);
1070
1071         return ret;
1072 }
1073
1074 static int
1075 nve0_ram_calc(struct nouveau_fb *pfb, u32 freq)
1076 {
1077         struct nouveau_clock *clk = nouveau_clock(pfb);
1078         struct nve0_ram *ram = (void *)pfb->ram;
1079         struct nouveau_ram_data *xits = &ram->base.xition;
1080         struct nouveau_ram_data *copy;
1081         int ret;
1082
1083         if (ram->base.next == NULL) {
1084                 ret = nve0_ram_calc_data(pfb, clk->read(clk, nv_clk_src_mem),
1085                                         &ram->base.former);
1086                 if (ret)
1087                         return ret;
1088
1089                 ret = nve0_ram_calc_data(pfb, freq, &ram->base.target);
1090                 if (ret)
1091                         return ret;
1092
1093                 if (ram->base.target.freq < ram->base.former.freq) {
1094                         *xits = ram->base.target;
1095                         copy = &ram->base.former;
1096                 } else {
1097                         *xits = ram->base.former;
1098                         copy = &ram->base.target;
1099                 }
1100
1101                 xits->bios.ramcfg_11_02_04 = copy->bios.ramcfg_11_02_04;
1102                 xits->bios.ramcfg_11_02_03 = copy->bios.ramcfg_11_02_03;
1103                 xits->bios.timing_20_30_07 = copy->bios.timing_20_30_07;
1104
1105                 ram->base.next = &ram->base.target;
1106                 if (memcmp(xits, &ram->base.former, sizeof(xits->bios)))
1107                         ram->base.next = &ram->base.xition;
1108         } else {
1109                 BUG_ON(ram->base.next != &ram->base.xition);
1110                 ram->base.next = &ram->base.target;
1111         }
1112
1113         return nve0_ram_calc_xits(pfb, ram->base.next);
1114 }
1115
1116 static int
1117 nve0_ram_prog(struct nouveau_fb *pfb)
1118 {
1119         struct nouveau_device *device = nv_device(pfb);
1120         struct nve0_ram *ram = (void *)pfb->ram;
1121         struct nve0_ramfuc *fuc = &ram->fuc;
1122         ram_exec(fuc, nouveau_boolopt(device->cfgopt, "NvMemExec", true));
1123         return (ram->base.next == &ram->base.xition);
1124 }
1125
1126 static void
1127 nve0_ram_tidy(struct nouveau_fb *pfb)
1128 {
1129         struct nve0_ram *ram = (void *)pfb->ram;
1130         struct nve0_ramfuc *fuc = &ram->fuc;
1131         ram->base.next = NULL;
1132         ram_exec(fuc, false);
1133 }
1134
1135 struct nve0_ram_train {
1136         u16 mask;
1137         struct nvbios_M0209S remap;
1138         struct nvbios_M0209S type00;
1139         struct nvbios_M0209S type01;
1140         struct nvbios_M0209S type04;
1141         struct nvbios_M0209S type06;
1142         struct nvbios_M0209S type07;
1143         struct nvbios_M0209S type08;
1144         struct nvbios_M0209S type09;
1145 };
1146
1147 static int
1148 nve0_ram_train_type(struct nouveau_fb *pfb, int i, u8 ramcfg,
1149                     struct nve0_ram_train *train)
1150 {
1151         struct nouveau_bios *bios = nouveau_bios(pfb);
1152         struct nvbios_M0205E M0205E;
1153         struct nvbios_M0205S M0205S;
1154         struct nvbios_M0209E M0209E;
1155         struct nvbios_M0209S *remap = &train->remap;
1156         struct nvbios_M0209S *value;
1157         u8  ver, hdr, cnt, len;
1158         u32 data;
1159
1160         /* determine type of data for this index */
1161         if (!(data = nvbios_M0205Ep(bios, i, &ver, &hdr, &cnt, &len, &M0205E)))
1162                 return -ENOENT;
1163
1164         switch (M0205E.type) {
1165         case 0x00: value = &train->type00; break;
1166         case 0x01: value = &train->type01; break;
1167         case 0x04: value = &train->type04; break;
1168         case 0x06: value = &train->type06; break;
1169         case 0x07: value = &train->type07; break;
1170         case 0x08: value = &train->type08; break;
1171         case 0x09: value = &train->type09; break;
1172         default:
1173                 return 0;
1174         }
1175
1176         /* training data index determined by ramcfg strap */
1177         if (!(data = nvbios_M0205Sp(bios, i, ramcfg, &ver, &hdr, &M0205S)))
1178                 return -EINVAL;
1179         i = M0205S.data;
1180
1181         /* training data format information */
1182         if (!(data = nvbios_M0209Ep(bios, i, &ver, &hdr, &cnt, &len, &M0209E)))
1183                 return -EINVAL;
1184
1185         /* ... and the raw data */
1186         if (!(data = nvbios_M0209Sp(bios, i, 0, &ver, &hdr, value)))
1187                 return -EINVAL;
1188
1189         if (M0209E.v02_07 == 2) {
1190                 /* of course! why wouldn't we have a pointer to another entry
1191                  * in the same table, and use the first one as an array of
1192                  * remap indices...
1193                  */
1194                 if (!(data = nvbios_M0209Sp(bios, M0209E.v03, 0, &ver, &hdr,
1195                                             remap)))
1196                         return -EINVAL;
1197
1198                 for (i = 0; i < ARRAY_SIZE(value->data); i++)
1199                         value->data[i] = remap->data[value->data[i]];
1200         } else
1201         if (M0209E.v02_07 != 1)
1202                 return -EINVAL;
1203
1204         train->mask |= 1 << M0205E.type;
1205         return 0;
1206 }
1207
1208 static int
1209 nve0_ram_train_init_0(struct nouveau_fb *pfb, struct nve0_ram_train *train)
1210 {
1211         int i, j;
1212
1213         if ((train->mask & 0x03d3) != 0x03d3) {
1214                 nv_warn(pfb, "missing link training data\n");
1215                 return -EINVAL;
1216         }
1217
1218         for (i = 0; i < 0x30; i++) {
1219                 for (j = 0; j < 8; j += 4) {
1220                         nv_wr32(pfb, 0x10f968 + j, 0x00000000 | (i << 8));
1221                         nv_wr32(pfb, 0x10f920 + j, 0x00000000 |
1222                                                    train->type08.data[i] << 4 |
1223                                                    train->type06.data[i]);
1224                         nv_wr32(pfb, 0x10f918 + j, train->type00.data[i]);
1225                         nv_wr32(pfb, 0x10f920 + j, 0x00000100 |
1226                                                    train->type09.data[i] << 4 |
1227                                                    train->type07.data[i]);
1228                         nv_wr32(pfb, 0x10f918 + j, train->type01.data[i]);
1229                 }
1230         }
1231
1232         for (j = 0; j < 8; j += 4) {
1233                 for (i = 0; i < 0x100; i++) {
1234                         nv_wr32(pfb, 0x10f968 + j, i);
1235                         nv_wr32(pfb, 0x10f900 + j, train->type04.data[i]);
1236                 }
1237         }
1238
1239         return 0;
1240 }
1241
1242 static int
1243 nve0_ram_train_init(struct nouveau_fb *pfb)
1244 {
1245         u8 ramcfg = nvbios_ramcfg_index(nv_subdev(pfb));
1246         struct nve0_ram_train *train;
1247         int ret = -ENOMEM, i;
1248
1249         if ((train = kzalloc(sizeof(*train), GFP_KERNEL))) {
1250                 for (i = 0; i < 0x100; i++) {
1251                         ret = nve0_ram_train_type(pfb, i, ramcfg, train);
1252                         if (ret && ret != -ENOENT)
1253                                 break;
1254                 }
1255         }
1256
1257         switch (pfb->ram->type) {
1258         case NV_MEM_TYPE_GDDR5:
1259                 ret = nve0_ram_train_init_0(pfb, train);
1260                 break;
1261         default:
1262                 ret = 0;
1263                 break;
1264         }
1265
1266         kfree(train);
1267         return ret;
1268 }
1269
1270 int
1271 nve0_ram_init(struct nouveau_object *object)
1272 {
1273         struct nouveau_fb *pfb = (void *)object->parent;
1274         struct nve0_ram *ram   = (void *)object;
1275         struct nouveau_bios *bios = nouveau_bios(pfb);
1276         u8  ver, hdr, cnt, len, snr, ssz;
1277         u32 data, save;
1278         int ret, i;
1279
1280         ret = nouveau_ram_init(&ram->base);
1281         if (ret)
1282                 return ret;
1283
1284         /* run a bunch of tables from rammap table.  there's actually
1285          * individual pointers for each rammap entry too, but, nvidia
1286          * seem to just run the last two entries' scripts early on in
1287          * their init, and never again.. we'll just run 'em all once
1288          * for now.
1289          *
1290          * i strongly suspect that each script is for a separate mode
1291          * (likely selected by 0x10f65c's lower bits?), and the
1292          * binary driver skips the one that's already been setup by
1293          * the init tables.
1294          */
1295         data = nvbios_rammapTe(bios, &ver, &hdr, &cnt, &len, &snr, &ssz);
1296         if (!data || hdr < 0x15)
1297                 return -EINVAL;
1298
1299         cnt  = nv_ro08(bios, data + 0x14); /* guess at count */
1300         data = nv_ro32(bios, data + 0x10); /* guess u32... */
1301         save = nv_rd32(pfb, 0x10f65c) & 0x000000f0;
1302         for (i = 0; i < cnt; i++, data += 4) {
1303                 if (i != save >> 4) {
1304                         nv_mask(pfb, 0x10f65c, 0x000000f0, i << 4);
1305                         nvbios_exec(&(struct nvbios_init) {
1306                                         .subdev = nv_subdev(pfb),
1307                                         .bios = bios,
1308                                         .offset = nv_ro32(bios, data),
1309                                         .execute = 1,
1310                                     });
1311                 }
1312         }
1313         nv_mask(pfb, 0x10f65c, 0x000000f0, save);
1314         nv_mask(pfb, 0x10f584, 0x11000000, 0x00000000);
1315         nv_wr32(pfb, 0x10ecc0, 0xffffffff);
1316         nv_mask(pfb, 0x10f160, 0x00000010, 0x00000010);
1317
1318         return nve0_ram_train_init(pfb);
1319 }
1320
1321 static int
1322 nve0_ram_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
1323               struct nouveau_oclass *oclass, void *data, u32 size,
1324               struct nouveau_object **pobject)
1325 {
1326         struct nouveau_fb *pfb = nouveau_fb(parent);
1327         struct nouveau_bios *bios = nouveau_bios(pfb);
1328         struct nouveau_gpio *gpio = nouveau_gpio(pfb);
1329         struct dcb_gpio_func func;
1330         struct nve0_ram *ram;
1331         int ret, i;
1332         u32 tmp;
1333
1334         ret = nvc0_ram_create(parent, engine, oclass, 0x022554, &ram);
1335         *pobject = nv_object(ram);
1336         if (ret)
1337                 return ret;
1338
1339         switch (ram->base.type) {
1340         case NV_MEM_TYPE_DDR3:
1341         case NV_MEM_TYPE_GDDR5:
1342                 ram->base.calc = nve0_ram_calc;
1343                 ram->base.prog = nve0_ram_prog;
1344                 ram->base.tidy = nve0_ram_tidy;
1345                 break;
1346         default:
1347                 nv_warn(pfb, "reclocking of this RAM type is unsupported\n");
1348                 break;
1349         }
1350
1351         /* calculate a mask of differently configured memory partitions,
1352          * because, of course reclocking wasn't complicated enough
1353          * already without having to treat some of them differently to
1354          * the others....
1355          */
1356         ram->parts = nv_rd32(pfb, 0x022438);
1357         ram->pmask = nv_rd32(pfb, 0x022554);
1358         ram->pnuts = 0;
1359         for (i = 0, tmp = 0; i < ram->parts; i++) {
1360                 if (!(ram->pmask & (1 << i))) {
1361                         u32 cfg1 = nv_rd32(pfb, 0x110204 + (i * 0x1000));
1362                         if (tmp && tmp != cfg1) {
1363                                 ram->pnuts |= (1 << i);
1364                                 continue;
1365                         }
1366                         tmp = cfg1;
1367                 }
1368         }
1369
1370         // parse bios data for both pll's
1371         ret = nvbios_pll_parse(bios, 0x0c, &ram->fuc.refpll);
1372         if (ret) {
1373                 nv_error(pfb, "mclk refpll data not found\n");
1374                 return ret;
1375         }
1376
1377         ret = nvbios_pll_parse(bios, 0x04, &ram->fuc.mempll);
1378         if (ret) {
1379                 nv_error(pfb, "mclk pll data not found\n");
1380                 return ret;
1381         }
1382
1383         ret = gpio->find(gpio, 0, 0x18, DCB_GPIO_UNUSED, &func);
1384         if (ret == 0) {
1385                 ram->fuc.r_gpioMV = ramfuc_reg(0x00d610 + (func.line * 0x04));
1386                 ram->fuc.r_funcMV[0] = (func.log[0] ^ 2) << 12;
1387                 ram->fuc.r_funcMV[1] = (func.log[1] ^ 2) << 12;
1388         }
1389
1390         ret = gpio->find(gpio, 0, 0x2e, DCB_GPIO_UNUSED, &func);
1391         if (ret == 0) {
1392                 ram->fuc.r_gpio2E = ramfuc_reg(0x00d610 + (func.line * 0x04));
1393                 ram->fuc.r_func2E[0] = (func.log[0] ^ 2) << 12;
1394                 ram->fuc.r_func2E[1] = (func.log[1] ^ 2) << 12;
1395         }
1396
1397         ram->fuc.r_gpiotrig = ramfuc_reg(0x00d604);
1398
1399         ram->fuc.r_0x132020 = ramfuc_reg(0x132020);
1400         ram->fuc.r_0x132028 = ramfuc_reg(0x132028);
1401         ram->fuc.r_0x132024 = ramfuc_reg(0x132024);
1402         ram->fuc.r_0x132030 = ramfuc_reg(0x132030);
1403         ram->fuc.r_0x132034 = ramfuc_reg(0x132034);
1404         ram->fuc.r_0x132000 = ramfuc_reg(0x132000);
1405         ram->fuc.r_0x132004 = ramfuc_reg(0x132004);
1406         ram->fuc.r_0x132040 = ramfuc_reg(0x132040);
1407
1408         ram->fuc.r_0x10f248 = ramfuc_reg(0x10f248);
1409         ram->fuc.r_0x10f290 = ramfuc_reg(0x10f290);
1410         ram->fuc.r_0x10f294 = ramfuc_reg(0x10f294);
1411         ram->fuc.r_0x10f298 = ramfuc_reg(0x10f298);
1412         ram->fuc.r_0x10f29c = ramfuc_reg(0x10f29c);
1413         ram->fuc.r_0x10f2a0 = ramfuc_reg(0x10f2a0);
1414         ram->fuc.r_0x10f2a4 = ramfuc_reg(0x10f2a4);
1415         ram->fuc.r_0x10f2a8 = ramfuc_reg(0x10f2a8);
1416         ram->fuc.r_0x10f2ac = ramfuc_reg(0x10f2ac);
1417         ram->fuc.r_0x10f2cc = ramfuc_reg(0x10f2cc);
1418         ram->fuc.r_0x10f2e8 = ramfuc_reg(0x10f2e8);
1419         ram->fuc.r_0x10f250 = ramfuc_reg(0x10f250);
1420         ram->fuc.r_0x10f24c = ramfuc_reg(0x10f24c);
1421         ram->fuc.r_0x10fec4 = ramfuc_reg(0x10fec4);
1422         ram->fuc.r_0x10fec8 = ramfuc_reg(0x10fec8);
1423         ram->fuc.r_0x10f604 = ramfuc_reg(0x10f604);
1424         ram->fuc.r_0x10f614 = ramfuc_reg(0x10f614);
1425         ram->fuc.r_0x10f610 = ramfuc_reg(0x10f610);
1426         ram->fuc.r_0x100770 = ramfuc_reg(0x100770);
1427         ram->fuc.r_0x100778 = ramfuc_reg(0x100778);
1428         ram->fuc.r_0x10f224 = ramfuc_reg(0x10f224);
1429
1430         ram->fuc.r_0x10f870 = ramfuc_reg(0x10f870);
1431         ram->fuc.r_0x10f698 = ramfuc_reg(0x10f698);
1432         ram->fuc.r_0x10f694 = ramfuc_reg(0x10f694);
1433         ram->fuc.r_0x10f6b8 = ramfuc_reg(0x10f6b8);
1434         ram->fuc.r_0x10f808 = ramfuc_reg(0x10f808);
1435         ram->fuc.r_0x10f670 = ramfuc_reg(0x10f670);
1436         ram->fuc.r_0x10f60c = ramfuc_reg(0x10f60c);
1437         ram->fuc.r_0x10f830 = ramfuc_reg(0x10f830);
1438         ram->fuc.r_0x1373ec = ramfuc_reg(0x1373ec);
1439         ram->fuc.r_0x10f800 = ramfuc_reg(0x10f800);
1440         ram->fuc.r_0x10f82c = ramfuc_reg(0x10f82c);
1441
1442         ram->fuc.r_0x10f978 = ramfuc_reg(0x10f978);
1443         ram->fuc.r_0x10f910 = ramfuc_reg(0x10f910);
1444         ram->fuc.r_0x10f914 = ramfuc_reg(0x10f914);
1445
1446         switch (ram->base.type) {
1447         case NV_MEM_TYPE_GDDR5:
1448                 ram->fuc.r_mr[0] = ramfuc_reg(0x10f300);
1449                 ram->fuc.r_mr[1] = ramfuc_reg(0x10f330);
1450                 ram->fuc.r_mr[2] = ramfuc_reg(0x10f334);
1451                 ram->fuc.r_mr[3] = ramfuc_reg(0x10f338);
1452                 ram->fuc.r_mr[4] = ramfuc_reg(0x10f33c);
1453                 ram->fuc.r_mr[5] = ramfuc_reg(0x10f340);
1454                 ram->fuc.r_mr[6] = ramfuc_reg(0x10f344);
1455                 ram->fuc.r_mr[7] = ramfuc_reg(0x10f348);
1456                 ram->fuc.r_mr[8] = ramfuc_reg(0x10f354);
1457                 ram->fuc.r_mr[15] = ramfuc_reg(0x10f34c);
1458                 break;
1459         case NV_MEM_TYPE_DDR3:
1460                 ram->fuc.r_mr[0] = ramfuc_reg(0x10f300);
1461                 ram->fuc.r_mr[2] = ramfuc_reg(0x10f320);
1462                 break;
1463         default:
1464                 break;
1465         }
1466
1467         ram->fuc.r_0x62c000 = ramfuc_reg(0x62c000);
1468         ram->fuc.r_0x10f200 = ramfuc_reg(0x10f200);
1469         ram->fuc.r_0x10f210 = ramfuc_reg(0x10f210);
1470         ram->fuc.r_0x10f310 = ramfuc_reg(0x10f310);
1471         ram->fuc.r_0x10f314 = ramfuc_reg(0x10f314);
1472         ram->fuc.r_0x10f318 = ramfuc_reg(0x10f318);
1473         ram->fuc.r_0x10f090 = ramfuc_reg(0x10f090);
1474         ram->fuc.r_0x10f69c = ramfuc_reg(0x10f69c);
1475         ram->fuc.r_0x10f824 = ramfuc_reg(0x10f824);
1476         ram->fuc.r_0x1373f0 = ramfuc_reg(0x1373f0);
1477         ram->fuc.r_0x1373f4 = ramfuc_reg(0x1373f4);
1478         ram->fuc.r_0x137320 = ramfuc_reg(0x137320);
1479         ram->fuc.r_0x10f65c = ramfuc_reg(0x10f65c);
1480         ram->fuc.r_0x10f6bc = ramfuc_reg(0x10f6bc);
1481         ram->fuc.r_0x100710 = ramfuc_reg(0x100710);
1482         ram->fuc.r_0x100750 = ramfuc_reg(0x100750);
1483         return 0;
1484 }
1485
1486 struct nouveau_oclass
1487 nve0_ram_oclass = {
1488         .handle = 0,
1489         .ofuncs = &(struct nouveau_ofuncs) {
1490                 .ctor = nve0_ram_ctor,
1491                 .dtor = _nouveau_ram_dtor,
1492                 .init = nve0_ram_init,
1493                 .fini = _nouveau_ram_fini,
1494         }
1495 };